Refactored c# token representation, it's now more consistent with the

other nodes and takes up a bit less memory.

ICSharpCode.NRefactory.CSharp/Ast/AstNode.cs

@@ -206,6 +206,12 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return lastChild; }
 		}
 		
+		public bool HasChildren {
+			get {
+				return firstChild != null;
+			}
+		}
+		
 		public IEnumerable<AstNode> Children {
 			get {
 				AstNode next;
@@ -648,7 +654,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// <param name='formattingOptions'>
 		/// Formatting options.
 		/// </param>
-		public string GetText (CSharpFormattingOptions formattingOptions = null)
+		public virtual string GetText (CSharpFormattingOptions formattingOptions = null)
 		{
 			if (IsNull)
 				return "";
@@ -711,23 +717,24 @@ namespace ICSharpCode.NRefactory.CSharp
 			public readonly static Role<Constraint> Constraint = new Role<Constraint> ("Constraint");
 			public static readonly Role<VariableInitializer> Variable = new Role<VariableInitializer> ("Variable", VariableInitializer.Null);
 			public static readonly Role<Statement> EmbeddedStatement = new Role<Statement> ("EmbeddedStatement", CSharp.Statement.Null);
-			public static readonly Role<CSharpTokenNode> Keyword = new Role<CSharpTokenNode> ("Keyword", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> InKeyword = new Role<CSharpTokenNode> ("InKeyword", CSharpTokenNode.Null);
+//			public static readonly TokenRole Keyword = new TokenRole ("Keyword", CSharpTokenNode.Null);
+//			public static readonly TokenRole InKeyword = new TokenRole ("InKeyword", CSharpTokenNode.Null);
 			
 			// some pre defined constants for most used punctuation
-			public static readonly Role<CSharpTokenNode> LPar = new Role<CSharpTokenNode> ("LPar", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> RPar = new Role<CSharpTokenNode> ("RPar", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> LBracket = new Role<CSharpTokenNode> ("LBracket", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> RBracket = new Role<CSharpTokenNode> ("RBracket", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> LBrace = new Role<CSharpTokenNode> ("LBrace", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> RBrace = new Role<CSharpTokenNode> ("RBrace", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> LChevron = new Role<CSharpTokenNode> ("LChevron", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> RChevron = new Role<CSharpTokenNode> ("RChevron", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> Comma = new Role<CSharpTokenNode> ("Comma", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> Dot = new Role<CSharpTokenNode> ("Dot", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> Semicolon = new Role<CSharpTokenNode> ("Semicolon", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> Assign = new Role<CSharpTokenNode> ("Assign", CSharpTokenNode.Null);
-			public static readonly Role<CSharpTokenNode> Colon = new Role<CSharpTokenNode> ("Colon", CSharpTokenNode.Null);
+			public static readonly TokenRole LPar = new TokenRole ("(");
+			public static readonly TokenRole RPar = new TokenRole (")");
+			public static readonly TokenRole LBracket = new TokenRole ("[");
+			public static readonly TokenRole RBracket = new TokenRole ("]");
+			public static readonly TokenRole LBrace = new TokenRole ("{");
+			public static readonly TokenRole RBrace = new TokenRole ("}");
+			public static readonly TokenRole LChevron = new TokenRole ("<");
+			public static readonly TokenRole RChevron = new TokenRole (">");
+			public static readonly TokenRole Comma = new TokenRole (",");
+			public static readonly TokenRole Dot = new TokenRole (".");
+			public static readonly TokenRole Semicolon = new TokenRole (";");
+			public static readonly TokenRole Assign = new TokenRole ("=");
+			public static readonly TokenRole Colon = new TokenRole (":");
+			public static readonly TokenRole DoubleColon = new TokenRole ("::");
 			public static readonly Role<Comment> Comment = new Role<Comment> ("Comment");
 			public static readonly Role<PreProcessorDirective> PreProcessorDirective = new Role<PreProcessorDirective> ("PreProcessorDirective");
 			public static readonly Role<ErrorNode> Error = new Role<ErrorNode> ("Error");

ICSharpCode.NRefactory.CSharp/Ast/CSharpModifierToken.cs

@@ -36,12 +36,20 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public Modifiers Modifier {
 			get { return modifier; }
-			set {
-				this.tokenLength = GetModifierName(value).Length;
-				this.modifier = value;
+			set { this.modifier = value; }
+		}
+		
+		protected override int TokenLength {
+			get {
+				return GetModifierName (modifier).Length;
 			}
 		}
 		
+		public override string GetText (CSharpFormattingOptions formattingOptions = null)
+		{
+			return GetModifierName (Modifier);
+		}
+		
 		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 		{
 			CSharpModifierToken o = other as CSharpModifierToken;
@@ -65,7 +73,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return allModifiers; }
 		}
 		
-		public CSharpModifierToken (TextLocation location, Modifiers modifier) : base (location, 0)
+		public CSharpModifierToken (TextLocation location, Modifiers modifier) : base (location)
 		{
 			this.Modifier = modifier;
 		}

ICSharpCode.NRefactory.CSharp/Ast/CSharpTokenNode.cs

@@ -38,7 +38,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 			}
 			
-			public NullCSharpTokenNode () : base (TextLocation.Empty, 0)
+			public NullCSharpTokenNode () : base (TextLocation.Empty)
 			{
 			}
 			
@@ -62,7 +62,6 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		
 		public override NodeType NodeType {
 			get {
 				return NodeType.Token;
@@ -76,17 +75,25 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		protected int tokenLength;
+		protected virtual int TokenLength {
+			get {
+				if (!(Role is TokenRole))
+					return 0;
+				return ((TokenRole)Role).Length;
+			}
+		}
+		
 		public override TextLocation EndLocation {
 			get {
-				return new TextLocation (StartLocation.Line, StartLocation.Column + tokenLength);
+				return new TextLocation (StartLocation.Line, StartLocation.Column + TokenLength);
 			}
 		}
 		
-		public CSharpTokenNode (TextLocation location, int tokenLength)
+		public CSharpTokenNode (TextLocation location)
 		{
+			Console.WriteLine ("--------------------------" + location);
+			Console.WriteLine (Environment.StackTrace);
 			this.startLocation = location;
-			this.tokenLength = tokenLength;
 		}
 		
 		#region IRelocationable implementation
@@ -96,6 +103,13 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		#endregion
 		
+		public override string GetText (CSharpFormattingOptions formattingOptions = null)
+		{
+			if (!(Role is TokenRole))
+				return null;
+			return ((TokenRole)Role).Token;
+		}
+
 		public override void AcceptVisitor (IAstVisitor visitor)
 		{
 			visitor.VisitCSharpTokenNode (this);

ICSharpCode.NRefactory.CSharp/Ast/ComposedType.cs

@@ -33,8 +33,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class ComposedType : AstType
 	{
-		public static readonly Role<CSharpTokenNode> NullableRole = new Role<CSharpTokenNode>("Nullable", CSharpTokenNode.Null);
-		public static readonly Role<CSharpTokenNode> PointerRole = new Role<CSharpTokenNode>("Pointer", CSharpTokenNode.Null);
+		public static readonly TokenRole NullableRole = new TokenRole("?");
+		public static readonly TokenRole PointerRole = new TokenRole("*");
 		public static readonly Role<ArraySpecifier> ArraySpecifierRole = new Role<ArraySpecifier>("ArraySpecifier");
 		
 		public AstType BaseType {
@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				return !GetChildByRole(NullableRole).IsNull;
 			}
 			set {
-				SetChildByRole(NullableRole, value ? new CSharpTokenNode(TextLocation.Empty, 1) : null);
+				SetChildByRole(NullableRole, value ? new CSharpTokenNode(TextLocation.Empty) : null);
 			}
 		}
 		
@@ -64,7 +64,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					d--;
 				}
 				while (d < value) {
-					InsertChildBefore(GetChildByRole(PointerRole), new CSharpTokenNode(TextLocation.Empty, 1), PointerRole);
+					InsertChildBefore(GetChildByRole(PointerRole), new CSharpTokenNode(TextLocation.Empty), PointerRole);
 					d++;
 				}
 			}
@@ -176,7 +176,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					d--;
 				}
 				while (d < value) {
-					InsertChildBefore(GetChildByRole(Roles.Comma), new CSharpTokenNode(TextLocation.Empty, 1), Roles.Comma);
+					InsertChildBefore(GetChildByRole(Roles.Comma), new CSharpTokenNode(TextLocation.Empty), Roles.Comma);
 					d++;
 				}
 			}

ICSharpCode.NRefactory.CSharp/Ast/Expressions/AnonymousMethodExpression.cs

@@ -34,7 +34,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class AnonymousMethodExpression : Expression
 	{
-		public readonly static Role<CSharpTokenNode> AsyncModifierRole = LambdaExpression.AsyncModifierRole;
+		public readonly static TokenRole DelegateKeywordRole = new TokenRole ("delegate");
+		public readonly static TokenRole AsyncModifierRole = LambdaExpression.AsyncModifierRole;
 		
 		public bool IsAsync { get; set; }
 		
@@ -44,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode DelegateToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (DelegateKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/AnonymousTypeCreateExpression.cs

@@ -33,8 +33,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class AnonymousTypeCreateExpression : Expression
 	{
+		public readonly static TokenRole NewKeywordRole = new TokenRole ("new");
+		
 		public CSharpTokenNode NewToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (NewKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/ArrayCreateExpression.cs

@@ -26,9 +26,14 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ArrayCreateExpression : Expression
 	{
+		public readonly static TokenRole NewKeywordRole = new TokenRole ("new");
 		public readonly static Role<ArraySpecifier> AdditionalArraySpecifierRole = new Role<ArraySpecifier>("AdditionalArraySpecifier");
 		public readonly static Role<ArrayInitializerExpression> InitializerRole = new Role<ArrayInitializerExpression>("Initializer", ArrayInitializerExpression.Null);
 		
+		public CSharpTokenNode NewToken {
+			get { return GetChildByRole (NewKeywordRole); }
+		}
+		
 		public AstType Type {
 			get { return GetChildByRole (Roles.Type); }
 			set { SetChildByRole (Roles.Type, value); }

ICSharpCode.NRefactory.CSharp/Ast/Expressions/AsExpression.cs

@@ -31,13 +31,15 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class AsExpression : Expression
 	{
+		public readonly static TokenRole AsKeywordRole = new TokenRole ("as");
+		
 		public Expression Expression {
 			get { return GetChildByRole (Roles.Expression); }
 			set { SetChildByRole(Roles.Expression, value); }
 		}
 		
 		public CSharpTokenNode AsToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (AsKeywordRole); }
 		}
 		
 		public AstType Type {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/AssignmentExpression.cs

@@ -36,9 +36,20 @@ namespace ICSharpCode.NRefactory.CSharp
 	{
 		// reuse roles from BinaryOperatorExpression
 		public readonly static Role<Expression> LeftRole = BinaryOperatorExpression.LeftRole;
-		public readonly static Role<CSharpTokenNode> OperatorRole = BinaryOperatorExpression.OperatorRole;
 		public readonly static Role<Expression> RightRole = BinaryOperatorExpression.RightRole;
 		
+		public readonly static TokenRole AssignRole = new TokenRole ("=");
+		public readonly static TokenRole AddRole = new TokenRole ("+=");
+		public readonly static TokenRole SubtractRole = new TokenRole ("-=");
+		public readonly static TokenRole MultiplyRole = new TokenRole ("*=");
+		public readonly static TokenRole DivideRole = new TokenRole ("/=");
+		public readonly static TokenRole ModulusRole = new TokenRole ("%=");
+		public readonly static TokenRole ShiftLeftRole = new TokenRole ("<<=");
+		public readonly static TokenRole ShiftRightRole = new TokenRole (">>=");
+		public readonly static TokenRole BitwiseAndRole = new TokenRole ("&=");
+		public readonly static TokenRole BitwiseOrRole = new TokenRole ("|=");
+		public readonly static TokenRole ExclusiveOrRole = new TokenRole ("^=");
+		
 		public AssignmentExpression()
 		{
 		}
@@ -67,7 +78,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode OperatorToken {
-			get { return GetChildByRole (OperatorRole); }
+			get { return GetChildByRole (GetOperatorRole(Operator)); }
 		}
 		
 		public Expression Right {
@@ -97,31 +108,31 @@ namespace ICSharpCode.NRefactory.CSharp
 				&& this.Left.DoMatch(o.Left, match) && this.Right.DoMatch(o.Right, match);
 		}
 		
-		public static string GetOperatorSymbol(AssignmentOperatorType op)
+		public static TokenRole GetOperatorRole(AssignmentOperatorType op)
 		{
 			switch (op) {
 				case AssignmentOperatorType.Assign:
-					return "=";
+					return AssignRole;
 				case AssignmentOperatorType.Add:
-					return "+=";
+					return AddRole;
 				case AssignmentOperatorType.Subtract:
-					return "-=";
+					return SubtractRole;
 				case AssignmentOperatorType.Multiply:
-					return "*=";
+					return MultiplyRole;
 				case AssignmentOperatorType.Divide:
-					return "/=";
+					return DivideRole;
 				case AssignmentOperatorType.Modulus:
-					return "%=";
+					return ModulusRole;
 				case AssignmentOperatorType.ShiftLeft:
-					return "<<=";
+					return ShiftLeftRole;
 				case AssignmentOperatorType.ShiftRight:
-					return ">>=";
+					return ShiftRightRole;
 				case AssignmentOperatorType.BitwiseAnd:
-					return "&=";
+					return BitwiseAndRole;
 				case AssignmentOperatorType.BitwiseOr:
-					return "|=";
+					return BitwiseOrRole;
 				case AssignmentOperatorType.ExclusiveOr:
-					return "^=";
+					return ExclusiveOrRole;
 				default:
 					throw new NotSupportedException("Invalid value for AssignmentOperatorType");
 			}

ICSharpCode.NRefactory.CSharp/Ast/Expressions/BinaryOperatorExpression.cs

@@ -34,8 +34,27 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class BinaryOperatorExpression : Expression
 	{
+		public readonly static TokenRole BitwiseAndRole = new TokenRole ("&");
+		public readonly static TokenRole BitwiseOrRole = new TokenRole ("|");
+		public readonly static TokenRole ConditionalAndRole = new TokenRole ("&&");
+		public readonly static TokenRole ConditionalOrRole = new TokenRole ("||");
+		public readonly static TokenRole ExclusiveOrRole = new TokenRole ("^");
+		public readonly static TokenRole GreaterThanRole = new TokenRole (">");
+		public readonly static TokenRole GreaterThanOrEqualRole = new TokenRole (">=");
+		public readonly static TokenRole EqualityRole = new TokenRole ("==");
+		public readonly static TokenRole InEqualityRole = new TokenRole ("!=");
+		public readonly static TokenRole LessThanRole = new TokenRole ("<");
+		public readonly static TokenRole LessThanOrEqualRole = new TokenRole ("<=");
+		public readonly static TokenRole AddRole = new TokenRole ("+");
+		public readonly static TokenRole SubtractRole = new TokenRole ("-");
+		public readonly static TokenRole MultiplyRole = new TokenRole ("*");
+		public readonly static TokenRole DivideRole = new TokenRole ("/");
+		public readonly static TokenRole ModulusRole = new TokenRole ("%");
+		public readonly static TokenRole ShiftLeftRole = new TokenRole ("<<");
+		public readonly static TokenRole ShiftRightRole = new TokenRole (">>");
+		public readonly static TokenRole NullCoalescingRole = new TokenRole ("??");
+		
 		public readonly static Role<Expression> LeftRole = new Role<Expression>("Left", Expression.Null);
-		public readonly static Role<CSharpTokenNode> OperatorRole = new Role<CSharpTokenNode>("Operator", CSharpTokenNode.Null);
 		public readonly static Role<Expression> RightRole = new Role<Expression>("Right", Expression.Null);
 		
 		public BinaryOperatorExpression()
@@ -60,7 +79,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode OperatorToken {
-			get { return GetChildByRole (OperatorRole); }
+			get { return GetChildByRole (GetOperatorRole (Operator)); }
 		}
 		
 		public Expression Right {
@@ -90,47 +109,47 @@ namespace ICSharpCode.NRefactory.CSharp
 				&& this.Left.DoMatch(o.Left, match) && this.Right.DoMatch(o.Right, match);
 		}
 		
-		public static string GetOperatorSymbol(BinaryOperatorType op)
+		public static TokenRole GetOperatorRole (BinaryOperatorType op)
 		{
 			switch (op) {
 				case BinaryOperatorType.BitwiseAnd:
-					return "&";
+					return BitwiseAndRole;
 				case BinaryOperatorType.BitwiseOr:
-					return "|";
+					return BitwiseOrRole;
 				case BinaryOperatorType.ConditionalAnd:
-					return "&&";
+					return ConditionalAndRole;
 				case BinaryOperatorType.ConditionalOr:
-					return "||";
+					return ConditionalOrRole;
 				case BinaryOperatorType.ExclusiveOr:
-					return "^";
+					return ExclusiveOrRole;
 				case BinaryOperatorType.GreaterThan:
-					return ">";
+					return GreaterThanRole;
 				case BinaryOperatorType.GreaterThanOrEqual:
-					return ">=";
+					return GreaterThanOrEqualRole;
 				case BinaryOperatorType.Equality:
-					return "==";
+					return EqualityRole;
 				case BinaryOperatorType.InEquality:
-					return "!=";
+					return InEqualityRole;
 				case BinaryOperatorType.LessThan:
-					return "<";
+					return LessThanRole;
 				case BinaryOperatorType.LessThanOrEqual:
-					return "<=";
+					return LessThanOrEqualRole;
 				case BinaryOperatorType.Add:
-					return "+";
+					return AddRole;
 				case BinaryOperatorType.Subtract:
-					return "-";
+					return SubtractRole;
 				case BinaryOperatorType.Multiply:
-					return "*";
+					return MultiplyRole;
 				case BinaryOperatorType.Divide:
-					return "/";
+					return DivideRole;
 				case BinaryOperatorType.Modulus:
-					return "%";
+					return ModulusRole;
 				case BinaryOperatorType.ShiftLeft:
-					return "<<";
+					return ShiftLeftRole;
 				case BinaryOperatorType.ShiftRight:
-					return ">>";
+					return ShiftRightRole;
 				case BinaryOperatorType.NullCoalescing:
-					return "??";
+					return NullCoalescingRole;
 				default:
 					throw new NotSupportedException("Invalid value for BinaryOperatorType");
 			}

ICSharpCode.NRefactory.CSharp/Ast/Expressions/CheckedExpression.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class CheckedExpression : Expression
 	{
+		public readonly static TokenRole CheckedKeywordRole = new TokenRole ("checked");
+		
 		public CSharpTokenNode CheckedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (CheckedKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/ConditionalExpression.cs

@@ -32,9 +32,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	public class ConditionalExpression : Expression
 	{
 		public readonly static Role<Expression> ConditionRole = Roles.Condition;
-		public readonly static Role<CSharpTokenNode> QuestionMarkRole = new Role<CSharpTokenNode>("QuestionMark", CSharpTokenNode.Null);
+		public readonly static TokenRole QuestionMarkRole = new TokenRole("?");
 		public readonly static Role<Expression> TrueRole = new Role<Expression>("True", Expression.Null);
-		public readonly static Role<CSharpTokenNode> ColonRole = Roles.Colon;
+		public readonly static TokenRole ColonRole = Roles.Colon;
 		public readonly static Role<Expression> FalseRole = new Role<Expression>("False", Expression.Null);
 		
 		public Expression Condition {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/DefaultValueExpression.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class DefaultValueExpression : Expression
 	{
+		public readonly static TokenRole DefaultKeywordRole = new TokenRole ("default");
+
 		public CSharpTokenNode DefaultToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (DefaultKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/DirectionExpression.cs

@@ -38,13 +38,16 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class DirectionExpression : Expression
 	{
+		public readonly static TokenRole RefKeywordRole = new TokenRole ("ref");
+		public readonly static TokenRole OutKeywordRole = new TokenRole ("out");
+		
 		public FieldDirection FieldDirection {
 			get;
 			set;
 		}
 		
 		public CSharpTokenNode FieldDirectionToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return FieldDirection == ICSharpCode.NRefactory.CSharp.FieldDirection.Ref ? GetChildByRole (RefKeywordRole) : GetChildByRole (OutKeywordRole); }
 		}
 		
 		public Expression Expression {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/IsExpression.cs

@@ -31,13 +31,15 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class IsExpression : Expression
 	{
+		public readonly static TokenRole IsKeywordRole = new TokenRole ("is");
+		
 		public Expression Expression {
 			get { return GetChildByRole(Roles.Expression); }
 			set { SetChildByRole(Roles.Expression, value); }
 		}
 		
 		public CSharpTokenNode IsToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (IsKeywordRole); }
 		}
 		
 		public AstType Type {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/LambdaExpression.cs

@@ -33,8 +33,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class LambdaExpression : Expression
 	{
-		public readonly static Role<CSharpTokenNode> AsyncModifierRole = new Role<CSharpTokenNode>("AsyncModifier", CSharpTokenNode.Null);
-		public readonly static Role<CSharpTokenNode> ArrowRole = new Role<CSharpTokenNode>("Arrow", CSharpTokenNode.Null);
+		public readonly static TokenRole AsyncModifierRole = new TokenRole ("async");
+		public readonly static TokenRole ArrowRole = new TokenRole ("=>");
 		public static readonly Role<AstNode> BodyRole = new Role<AstNode>("Body", AstNode.Null);
 		
 		public bool IsAsync { get; set; }

ICSharpCode.NRefactory.CSharp/Ast/Expressions/ObjectCreateExpression.cs

@@ -33,10 +33,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ObjectCreateExpression : Expression
 	{
+		public readonly static TokenRole NewKeywordRole = new TokenRole ("new");
 		public readonly static Role<ArrayInitializerExpression> InitializerRole = ArrayCreateExpression.InitializerRole;
 		
 		public CSharpTokenNode NewToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (NewKeywordRole); }
 		}
 		
 		public AstType Type {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/PointerReferenceExpression.cs

@@ -33,13 +33,17 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class PointerReferenceExpression : Expression
 	{
-		public readonly static Role<CSharpTokenNode> ArrowRole = new Role<CSharpTokenNode>("Arrow", CSharpTokenNode.Null);
+		public readonly static TokenRole ArrowRole = new TokenRole ("->");
 		
 		public Expression Target {
 			get { return GetChildByRole (Roles.TargetExpression); }
 			set { SetChildByRole(Roles.TargetExpression, value); }
 		}
 		
+		public CSharpTokenNode ArrowToken {
+			get { return GetChildByRole (ArrowRole); }
+		}
+
 		public string MemberName {
 			get {
 				return GetChildByRole (Roles.Identifier).Name;

ICSharpCode.NRefactory.CSharp/Ast/Expressions/QueryExpression.cs

@@ -111,7 +111,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	public class QueryContinuationClause : QueryClause
 	{
 		public static readonly Role<QueryExpression> PrecedingQueryRole = new Role<QueryExpression>("PrecedingQuery", QueryExpression.Null);
-		public static readonly Role<CSharpTokenNode> IntoKeywordRole = Roles.Keyword;
+		public static readonly TokenRole IntoKeywordRole = new TokenRole ("into");
 		
 		public QueryExpression PrecedingQuery {
 			get { return GetChildByRole(PrecedingQueryRole); }
@@ -155,8 +155,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryFromClause : QueryClause
 	{
-		public static readonly Role<CSharpTokenNode> FromKeywordRole = Roles.Keyword;
-		public static readonly Role<CSharpTokenNode> InKeywordRole = Roles.InKeyword;
+		public static readonly TokenRole FromKeywordRole =  new TokenRole ("from");
+		public static readonly TokenRole InKeywordRole =  new TokenRole ("in");
 		
 		public AstType Type {
 			get { return GetChildByRole (Roles.Type); }
@@ -206,8 +206,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryLetClause : QueryClause
 	{
+		public readonly static TokenRole LetKeywordRole = new TokenRole ("let");
+		
 		public CSharpTokenNode LetKeyword {
-			get { return GetChildByRole(Roles.Keyword); }
+			get { return GetChildByRole(LetKeywordRole); }
 		}
 		
 		public string Identifier {
@@ -257,8 +259,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryWhereClause : QueryClause
 	{
+		public readonly static TokenRole WhereKeywordRole = new TokenRole ("where");
+
 		public CSharpTokenNode WhereKeyword {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (WhereKeywordRole); }
 		}
 		
 		public Expression Condition {
@@ -293,16 +297,16 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class QueryJoinClause : QueryClause
 	{
-		public static readonly Role<CSharpTokenNode> JoinKeywordRole = Roles.Keyword;
+		public static readonly TokenRole JoinKeywordRole = new TokenRole ("join");
 		public static readonly Role<AstType> TypeRole = Roles.Type;
 		public static readonly Role<Identifier> JoinIdentifierRole = Roles.Identifier;
-		public static readonly Role<CSharpTokenNode> InKeywordRole = Roles.InKeyword;
+		public static readonly TokenRole InKeywordRole =  new TokenRole ("in");
 		public static readonly Role<Expression> InExpressionRole = Roles.Expression;
-		public static readonly Role<CSharpTokenNode> OnKeywordRole = new Role<CSharpTokenNode>("OnKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole OnKeywordRole =  new TokenRole ("on");
 		public static readonly Role<Expression> OnExpressionRole = new Role<Expression>("OnExpression", Expression.Null);
-		public static readonly Role<CSharpTokenNode> EqualsKeywordRole = new Role<CSharpTokenNode>("EqualsKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole EqualsKeywordRole =  new TokenRole ("equals");
 		public static readonly Role<Expression> EqualsExpressionRole = new Role<Expression>("EqualsExpression", Expression.Null);
-		public static readonly Role<CSharpTokenNode> IntoKeywordRole = new Role<CSharpTokenNode>("IntoKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole IntoKeywordRole =  new TokenRole ("into");
 		public static readonly Role<Identifier> IntoIdentifierRole = new Role<Identifier>("IntoIdentifier", Identifier.Null);
 		
 		public bool IsGroupJoin {
@@ -403,10 +407,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryOrderClause : QueryClause
 	{
+		public static readonly TokenRole OrderbyKeywordRole = new TokenRole ("orderby");
 		public static readonly Role<QueryOrdering> OrderingRole = new Role<QueryOrdering>("Ordering");
 		
-		public CSharpTokenNode Keyword {
-			get { return GetChildByRole (Roles.Keyword); }
+		public CSharpTokenNode OrderbyToken {
+			get { return GetChildByRole (OrderbyKeywordRole); }
 		}
 		
 		public AstNodeCollection<QueryOrdering> Orderings {
@@ -437,6 +442,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryOrdering : AstNode
 	{
+		public readonly static TokenRole AscendingKeywordRole = new TokenRole ("ascending");
+		public readonly static TokenRole DescendingKeywordRole = new TokenRole ("descending");
+
 		public override NodeType NodeType {
 			get { return NodeType.Unknown; }
 		}
@@ -452,7 +460,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode DirectionToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return Direction == QueryOrderingDirection.Ascending ? GetChildByRole (AscendingKeywordRole) : GetChildByRole (DescendingKeywordRole); }
 		}
 		
 		public override void AcceptVisitor (IAstVisitor visitor)
@@ -486,8 +494,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QuerySelectClause : QueryClause
 	{
+		public readonly static TokenRole SelectKeywordRole = new TokenRole ("select");
+
 		public CSharpTokenNode SelectKeyword {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (SelectKeywordRole); }
 		}
 		
 		public Expression Expression {
@@ -519,9 +529,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class QueryGroupClause : QueryClause
 	{
-		public static readonly Role<CSharpTokenNode> GroupKeywordRole = Roles.Keyword;
+		public static readonly TokenRole GroupKeywordRole = new TokenRole ("group");
 		public static readonly Role<Expression> ProjectionRole = new Role<Expression>("Projection", Expression.Null);
-		public static readonly Role<CSharpTokenNode> ByKeywordRole = new Role<CSharpTokenNode>("ByKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole ByKeywordRole = new TokenRole ("by");
 		public static readonly Role<Expression> KeyRole = new Role<Expression>("Key", Expression.Null);
 		
 		public CSharpTokenNode GroupKeyword {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/SizeOfExpression.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class SizeOfExpression : Expression
 	{
+		public readonly static TokenRole SizeofKeywordRole = new TokenRole ("sizeof");
+		
 		public CSharpTokenNode SizeOfToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (SizeofKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/StackAllocExpression.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class StackAllocExpression : Expression
 	{
+		public readonly static TokenRole StackallocKeywordRole = new TokenRole ("stackalloc");
+		
 		public CSharpTokenNode StackAllocToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (StackallocKeywordRole); }
 		}
 		
 		public AstType Type {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/TypeOfExpression.cs

@@ -32,8 +32,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class TypeOfExpression : Expression
 	{
+		public readonly static TokenRole TypeofKeywordRole = new TokenRole ("typeof");
+		
 		public CSharpTokenNode TypeOfToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (TypeofKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/UnaryOperatorExpression.cs

@@ -34,7 +34,15 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UnaryOperatorExpression : Expression
 	{
-		public readonly static Role<CSharpTokenNode> OperatorRole = BinaryOperatorExpression.OperatorRole;
+		public readonly static TokenRole NotRole = new TokenRole ("!");
+		public readonly static TokenRole BitNotRole = new TokenRole ("~");
+		public readonly static TokenRole MinusRole = new TokenRole ("-");
+		public readonly static TokenRole PlusRole = new TokenRole ("+");
+		public readonly static TokenRole IncrementRole = new TokenRole ("++");
+		public readonly static TokenRole DecrementRole = new TokenRole ("--");
+		public readonly static TokenRole DereferenceRole = new TokenRole ("*");
+		public readonly static TokenRole AddressOfRole = new TokenRole ("&");
+		public readonly static TokenRole AwaitRole = new TokenRole ("await");
 		
 		public UnaryOperatorExpression()
 		{
@@ -52,7 +60,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode OperatorToken {
-			get { return GetChildByRole (OperatorRole); }
+			get { return GetChildByRole (GetOperatorRole (Operator)); }
 		}
 		
 		public Expression Expression {
@@ -82,29 +90,29 @@ namespace ICSharpCode.NRefactory.CSharp
 				&& this.Expression.DoMatch(o.Expression, match);
 		}
 		
-		public static string GetOperatorSymbol(UnaryOperatorType op)
+		public static TokenRole GetOperatorRole(UnaryOperatorType op)
 		{
 			switch (op) {
 				case UnaryOperatorType.Not:
-					return "!";
+					return NotRole;
 				case UnaryOperatorType.BitNot:
-					return "~";
+					return BitNotRole;
 				case UnaryOperatorType.Minus:
-					return "-";
+					return MinusRole;
 				case UnaryOperatorType.Plus:
-					return "+";
+					return PlusRole;
 				case UnaryOperatorType.Increment:
 				case UnaryOperatorType.PostIncrement:
-					return "++";
+					return IncrementRole;
 				case UnaryOperatorType.PostDecrement:
 				case UnaryOperatorType.Decrement:
-					return "--";
+					return DecrementRole;
 				case UnaryOperatorType.Dereference:
-					return "*";
+					return DereferenceRole;
 				case UnaryOperatorType.AddressOf:
-					return "&";
+					return AddressOfRole;
 				case UnaryOperatorType.Await:
-					return "await";
+					return AwaitRole;
 				default:
 					throw new NotSupportedException("Invalid value for UnaryOperatorType");
 			}

ICSharpCode.NRefactory.CSharp/Ast/Expressions/UncheckedExpression.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UncheckedExpression : Expression
 	{
+		public readonly static TokenRole UncheckedKeywordRole = new TokenRole ("unchecked");
+
 		public CSharpTokenNode UncheckedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UncheckedKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Expressions/UndocumentedExpression.cs

@@ -42,12 +42,30 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UndocumentedExpression : Expression
 	{
+		public readonly static TokenRole ArglistKeywordRole = new TokenRole ("__arglist");
+		public readonly static TokenRole RefvalueKeywordRole = new TokenRole ("__refvalue");
+		public readonly static TokenRole ReftypeKeywordRole = new TokenRole ("__reftype");
+		public readonly static TokenRole MakerefKeywordRole = new TokenRole ("__makeref");
+		
 		public UndocumentedExpressionType UndocumentedExpressionType {
 			get; set;
 		}
 		
 		public CSharpTokenNode UndocumentedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get {
+				switch (UndocumentedExpressionType) {
+				case ICSharpCode.NRefactory.CSharp.UndocumentedExpressionType.ArgListAccess:
+				case ICSharpCode.NRefactory.CSharp.UndocumentedExpressionType.ArgList:
+					return GetChildByRole (ArglistKeywordRole);
+				case ICSharpCode.NRefactory.CSharp.UndocumentedExpressionType.RefValue:
+					return GetChildByRole (RefvalueKeywordRole);
+				case ICSharpCode.NRefactory.CSharp.UndocumentedExpressionType.RefType:
+					return GetChildByRole (ReftypeKeywordRole);
+				case ICSharpCode.NRefactory.CSharp.UndocumentedExpressionType.MakeRef:
+					return GetChildByRole (MakerefKeywordRole);
+				}
+				return CSharpTokenNode.Null;
+			}
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/Constraint.cs

@@ -36,7 +36,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </remarks>
 	public class Constraint : AstNode
 	{
-		public readonly static Role<CSharpTokenNode> ColonRole = TypeDeclaration.ColonRole;
+		public readonly static TokenRole WhereKeywordRole = new TokenRole ("where");
+		public readonly static TokenRole ColonRole = TypeDeclaration.ColonRole;
 		public readonly static Role<AstType> BaseTypeRole = TypeDeclaration.BaseTypeRole;
 		public readonly static Role<SimpleType> TypeParameterRole = new Role<SimpleType> ("TypeParameter", SimpleType.Null);
 		

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/DelegateDeclaration.cs

@@ -34,12 +34,18 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class DelegateDeclaration : AttributedNode
 	{
+		public readonly static TokenRole DelegateKeywordRole = new TokenRole ("delegate");
+		
 		public override NodeType NodeType {
 			get {
 				return NodeType.TypeDeclaration;
 			}
 		}
 		
+		public CSharpTokenNode DelegateToken {
+			get { return GetChildByRole (DelegateKeywordRole); }
+		}
+		
 		public AstType ReturnType {
 			get { return GetChildByRole (Roles.Type); }
 			set { SetChildByRole (Roles.Type, value); }

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/ExternAliasDeclaration.cs

@@ -31,8 +31,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ExternAliasDeclaration : AstNode
 	{
-		public static readonly Role<CSharpTokenNode> AliasRole = new Role<CSharpTokenNode> ("Alias", CSharpTokenNode.Null);
-
+		public static readonly TokenRole ExternKeywordRole = new TokenRole ("extern");
+		public static readonly TokenRole AliasKeywordRole = new TokenRole ("alias");
+		
 		public override NodeType NodeType {
 			get {
 				return NodeType.Unknown;
@@ -40,11 +41,11 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 
 		public CSharpTokenNode ExternToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (ExternKeywordRole); }
 		}
 
 		public CSharpTokenNode AliasToken {
-			get { return GetChildByRole (AliasRole); }
+			get { return GetChildByRole (AliasKeywordRole); }
 		}
 
 		public string Name {

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/NamespaceDeclaration.cs

@@ -35,6 +35,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class NamespaceDeclaration : AstNode
 	{
+		public static readonly TokenRole NamespaceKeywordRole = new TokenRole ("namespace");
+		
 		public static readonly Role<AstNode> MemberRole = CompilationUnit.MemberRole;
 		
 		public override NodeType NodeType {
@@ -43,6 +45,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
+		public CSharpTokenNode NamespaceToken {
+			get { return GetChildByRole (NamespaceKeywordRole); }
+		}
+		
 		public string Name {
 			get {
 				StringBuilder builder = new StringBuilder ();

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeDeclaration.cs

@@ -43,7 +43,12 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class TypeDeclaration : AttributedNode
 	{
-		public readonly static Role<CSharpTokenNode> ColonRole = Roles.Colon;
+		public static readonly TokenRole EnumKeywordRole = new TokenRole ("enum");
+		public static readonly TokenRole InterfaceKeywordRole = new TokenRole ("interface");
+		public static readonly TokenRole StructKeywordRole = new TokenRole ("struct");
+		public static readonly TokenRole ClassKeywordRole = new TokenRole ("class");
+		
+		public readonly static TokenRole ColonRole = Roles.Colon;
 		public readonly static Role<AstType> BaseTypeRole = new Role<AstType>("BaseType", AstType.Null);
 		public readonly static Role<AttributedNode> MemberRole = new Role<AttributedNode>("Member");
 		

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/TypeParameterDeclaration.cs

@@ -31,7 +31,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	public class TypeParameterDeclaration : AstNode
 	{
 		public static readonly Role<AttributeSection> AttributeRole = AttributedNode.AttributeRole;
-		public static readonly Role<CSharpTokenNode> VarianceRole = new Role<CSharpTokenNode>("Variance", CSharpTokenNode.Null);
+		public static readonly TokenRole OutVarianceKeywordRole = new TokenRole ("out");
+		public static readonly TokenRole InVarianceKeywordRole = new TokenRole ("in");
 		
 		public override NodeType NodeType {
 			get { return NodeType.Unknown; }

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/UsingAliasDeclaration.cs

@@ -31,6 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UsingAliasDeclaration : AstNode
 	{
+		public static readonly TokenRole UsingKeywordRole = new TokenRole ("using");
 		public static readonly Role<Identifier> AliasRole = new Role<Identifier>("Alias", Identifier.Null);
 		public static readonly Role<AstType> ImportRole = UsingDeclaration.ImportRole;
 		
@@ -41,7 +42,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode UsingToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UsingKeywordRole); }
 		}
 		
 		public string Alias {

ICSharpCode.NRefactory.CSharp/Ast/GeneralScope/UsingDeclaration.cs

@@ -35,6 +35,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UsingDeclaration : AstNode
 	{
+		public static readonly TokenRole UsingKeywordRole = new TokenRole ("using");
 		public static readonly Role<AstType> ImportRole = new Role<AstType>("Import", AstType.Null);
 		
 		public override NodeType NodeType {
@@ -44,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode UsingToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UsingKeywordRole); }
 		}
 		
 		public AstType Import {

ICSharpCode.NRefactory.CSharp/Ast/Statements/BreakStatement.cs

@@ -31,6 +31,12 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class BreakStatement : Statement
 	{
+		public static readonly TokenRole BreakKeywordRole = new TokenRole ("break");
+		
+		public CSharpTokenNode BreakToken {
+			get { return GetChildByRole (BreakKeywordRole); }
+		}
+		
 		public CSharpTokenNode SemicolonToken {
 			get { return GetChildByRole (Roles.Semicolon); }
 		}

ICSharpCode.NRefactory.CSharp/Ast/Statements/CheckedStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class CheckedStatement : Statement
 	{
+		public static readonly TokenRole CheckedKeywordRole = new TokenRole ("checked");
+		
 		public CSharpTokenNode CheckedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (CheckedKeywordRole); }
 		}
 		
 		public BlockStatement Body {

ICSharpCode.NRefactory.CSharp/Ast/Statements/ContinueStatement.cs

@@ -31,6 +31,12 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ContinueStatement : Statement
 	{
+		public static readonly TokenRole ContinueKeywordRole = new TokenRole ("continue");
+		
+		public CSharpTokenNode ContinueToken {
+			get { return GetChildByRole (ContinueKeywordRole); }
+		}
+		
 		public CSharpTokenNode SemicolonToken {
 			get { return GetChildByRole (Roles.Semicolon); }
 		}

ICSharpCode.NRefactory.CSharp/Ast/Statements/DoWhileStatement.cs

@@ -31,8 +31,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class DoWhileStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> DoKeywordRole = new Role<CSharpTokenNode>("DoKeyword", CSharpTokenNode.Null);
-		public static readonly Role<CSharpTokenNode> WhileKeywordRole = new Role<CSharpTokenNode>("WhileKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole DoKeywordRole = new TokenRole ("do");
+		public static readonly TokenRole WhileKeywordRole = new TokenRole ("while");
 		
 		public CSharpTokenNode DoToken {
 			get { return GetChildByRole (DoKeywordRole); }

ICSharpCode.NRefactory.CSharp/Ast/Statements/FixedStatement.cs

@@ -33,8 +33,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class FixedStatement : Statement
 	{
+		public static readonly TokenRole FixedKeywordRole = new TokenRole ("fixed");
+		
 		public CSharpTokenNode FixedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (FixedKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/ForStatement.cs

@@ -33,11 +33,12 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ForStatement : Statement
 	{
+		public static readonly TokenRole ForKeywordRole = new TokenRole ("for");
 		public readonly static Role<Statement> InitializerRole = new Role<Statement>("Initializer", Statement.Null);
 		public readonly static Role<Statement> IteratorRole = new Role<Statement>("Iterator", Statement.Null);
 		
 		public CSharpTokenNode ForToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (ForKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/ForeachStatement.cs

@@ -31,8 +31,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ForeachStatement : Statement
 	{
+		public static readonly TokenRole ForeachKeywordRole = new TokenRole ("foreach");
+		public static readonly TokenRole InKeywordRole = new TokenRole ("in");
+		
 		public CSharpTokenNode ForeachToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (ForeachKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {
@@ -63,7 +66,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode InToken {
-			get { return GetChildByRole (Roles.InKeyword); }
+			get { return GetChildByRole (InKeywordRole); }
 		}
 		
 		public Expression InExpression {

ICSharpCode.NRefactory.CSharp/Ast/Statements/GotoStatement.cs

@@ -31,6 +31,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class GotoStatement : Statement
 	{
+		public static readonly TokenRole GotoKeywordRole = new TokenRole ("goto");
+		
 		public GotoStatement ()
 		{
 		}
@@ -41,7 +43,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode GotoToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (GotoKeywordRole); }
 		}
 		
 		public string Label {
@@ -87,10 +89,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class GotoCaseStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> CaseKeywordRole = new Role<CSharpTokenNode>("CaseKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole GotoKeywordRole = new TokenRole ("goto");
+		public static readonly TokenRole CaseKeywordRole = new TokenRole ("case");
 		
 		public CSharpTokenNode GotoToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (GotoKeywordRole); }
 		}
 		
 		public CSharpTokenNode CaseToken {
@@ -136,10 +139,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class GotoDefaultStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> DefaultKeywordRole = new Role<CSharpTokenNode>("DefaultKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole GotoKeywordRole = new TokenRole ("goto");
+		public static readonly TokenRole DefaultKeywordRole = new TokenRole ("default");
 		
 		public CSharpTokenNode GotoToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (GotoKeywordRole); }
 		}
 		
 		public CSharpTokenNode DefaultToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/IfElseStatement.cs

@@ -31,11 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class IfElseStatement : Statement
 	{
-		public readonly static Role<CSharpTokenNode> IfKeywordRole = Roles.Keyword;
+		public readonly static TokenRole IfKeywordRole = new TokenRole ("if");
 		public readonly static Role<Expression> ConditionRole = Roles.Condition;
-		public readonly static Role<CSharpTokenNode> QuestionMarkRole = new Role<CSharpTokenNode>("QuestionMark", CSharpTokenNode.Null);
 		public readonly static Role<Statement> TrueRole = new Role<Statement>("True", Statement.Null);
-		public readonly static Role<CSharpTokenNode> ElseKeywordRole = new Role<CSharpTokenNode>("ElseKeyword", CSharpTokenNode.Null);
+		public readonly static TokenRole ElseKeywordRole = new TokenRole ("else");
 		public readonly static Role<Statement> FalseRole = new Role<Statement>("False", Statement.Null);
 		
 		public CSharpTokenNode IfToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/LockStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class LockStatement : Statement
 	{
+		public static readonly TokenRole LockKeywordRole = new TokenRole ("lock");
+		
 		public CSharpTokenNode LockToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (LockKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/ReturnStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ReturnStatement : Statement
 	{
+		public static readonly TokenRole ReturnKeywordRole = new TokenRole ("return");
+
 		public CSharpTokenNode ReturnToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (ReturnKeywordRole); }
 		}
 		
 		public Expression Expression {

ICSharpCode.NRefactory.CSharp/Ast/Statements/SwitchStatement.cs

@@ -34,10 +34,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class SwitchStatement : Statement
 	{
+		public static readonly TokenRole SwitchKeywordRole = new TokenRole ("switch");
 		public static readonly Role<SwitchSection> SwitchSectionRole = new Role<SwitchSection>("SwitchSection");
 		
 		public CSharpTokenNode SwitchToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (SwitchKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {
@@ -175,6 +176,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class CaseLabel : AstNode
 	{
+		public static readonly TokenRole CaseKeywordRole = new TokenRole ("case");
+		public static readonly TokenRole DefaultKeywordRole = new TokenRole ("default");
+		
 		public override NodeType NodeType {
 			get {
 				return NodeType.Unknown;

ICSharpCode.NRefactory.CSharp/Ast/Statements/ThrowStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class ThrowStatement : Statement
 	{
+		public static readonly TokenRole ThrowKeywordRole = new TokenRole ("throw");
+		
 		public CSharpTokenNode ThrowToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (ThrowKeywordRole); }
 		}
 		
 		public Expression Expression {

ICSharpCode.NRefactory.CSharp/Ast/Statements/TryCatchStatement.cs

@@ -34,10 +34,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class TryCatchStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> TryKeywordRole = new Role<CSharpTokenNode>("TryKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole TryKeywordRole = new TokenRole ("try");
 		public static readonly Role<BlockStatement> TryBlockRole = new Role<BlockStatement>("TryBlock", BlockStatement.Null);
 		public static readonly Role<CatchClause> CatchClauseRole = new Role<CatchClause>("CatchClause");
-		public static readonly Role<CSharpTokenNode> FinallyKeywordRole = new Role<CSharpTokenNode>("FinallyKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole FinallyKeywordRole = new TokenRole ("finally");
 		public static readonly Role<BlockStatement> FinallyBlockRole = new Role<BlockStatement>("FinallyBlock", BlockStatement.Null);
 		
 		public CSharpTokenNode TryToken {
@@ -89,6 +89,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class CatchClause : AstNode
 	{
+		public static readonly TokenRole CatchKeywordRole = new TokenRole ("catch");
+		
 		#region PatternPlaceholder
 		public static implicit operator CatchClause(PatternMatching.Pattern pattern)
 		{
@@ -142,7 +144,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode CatchToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (CatchKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/UncheckedStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UncheckedStatement : Statement
 	{
+		public static readonly TokenRole UncheckedKeywordRole = new TokenRole ("unchecked");
+		
 		public CSharpTokenNode UncheckedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UncheckedKeywordRole); }
 		}
 		
 		public BlockStatement Body {

ICSharpCode.NRefactory.CSharp/Ast/Statements/UnsafeStatement.cs

@@ -31,8 +31,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UnsafeStatement : Statement
 	{
+		public static readonly TokenRole UnsafeKeywordRole = new TokenRole ("unsafe");
+		
 		public CSharpTokenNode UnsafeToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UnsafeKeywordRole); }
 		}
 		
 		public BlockStatement Body {

ICSharpCode.NRefactory.CSharp/Ast/Statements/UsingStatement.cs

@@ -31,10 +31,11 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class UsingStatement : Statement
 	{
+		public static readonly TokenRole UsingKeywordRole = new TokenRole ("using");
 		public static readonly Role<AstNode> ResourceAcquisitionRole = new Role<AstNode>("ResourceAcquisition", AstNode.Null);
 		
 		public CSharpTokenNode UsingToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (UsingKeywordRole); }
 		}
 		
 		public CSharpTokenNode LParToken {

ICSharpCode.NRefactory.CSharp/Ast/Statements/WhileStatement.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class WhileStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> WhileKeywordRole = new Role<CSharpTokenNode>("WhileKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole WhileKeywordRole = new TokenRole ("while");
 		
 		public CSharpTokenNode WhileToken {
 			get { return GetChildByRole (WhileKeywordRole); }

ICSharpCode.NRefactory.CSharp/Ast/Statements/YieldBreakStatement.cs

@@ -31,8 +31,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class YieldBreakStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> YieldKeywordRole = new Role<CSharpTokenNode>("YieldKeyword", CSharpTokenNode.Null);
-		public static readonly Role<CSharpTokenNode> BreakKeywordRole = new Role<CSharpTokenNode>("BreakKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole YieldKeywordRole = new TokenRole ("yield");
+		public static readonly TokenRole BreakKeywordRole = new TokenRole ("break");
 		
 		public CSharpTokenNode YieldToken {
 			get { return GetChildByRole (YieldKeywordRole); }

ICSharpCode.NRefactory.CSharp/Ast/Statements/YieldReturnStatement.cs

@@ -31,8 +31,8 @@ namespace ICSharpCode.NRefactory.CSharp
 	/// </summary>
 	public class YieldReturnStatement : Statement
 	{
-		public static readonly Role<CSharpTokenNode> YieldKeywordRole = new Role<CSharpTokenNode>("YieldKeyword", CSharpTokenNode.Null);
-		public static readonly Role<CSharpTokenNode> ReturnKeywordRole = new Role<CSharpTokenNode>("ReturnKeyword", CSharpTokenNode.Null);
+		public static readonly TokenRole YieldKeywordRole = new TokenRole ("yield");
+		public static readonly TokenRole ReturnKeywordRole = new TokenRole ("return");
 		
 		public CSharpTokenNode YieldToken {
 			get { return GetChildByRole (YieldKeywordRole); }

ICSharpCode.NRefactory.CSharp/Ast/TokenRole.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace ICSharpCode.NRefactory.CSharp
+{
+	public sealed class TokenRole : Role<CSharpTokenNode>
+	{
+		public string Token {
+			get;
+			private set;
+		}
+		
+		public int Length {
+			get;
+			private set;
+		}
+		
+		public TokenRole (string token) : base (token, CSharpTokenNode.Null)
+		{
+			this.Token = token;
+			this.Length = token.Length;
+		}
+	}
+}
+

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ConstructorDeclaration.cs

@@ -105,6 +105,9 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class ConstructorInitializer : AstNode
 	{
+		public static readonly TokenRole BaseKeywordRole = new TokenRole ("base");
+		public static readonly TokenRole ThisKeywordRole = new TokenRole ("this");
+		
 		public static readonly new ConstructorInitializer Null = new NullConstructorInitializer ();
 		class NullConstructorInitializer : ConstructorInitializer
 		{

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/DestructorDeclaration.cs

@@ -28,7 +28,7 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class DestructorDeclaration : AttributedNode
 	{
-		public static readonly Role<CSharpTokenNode> TildeRole = new Role<CSharpTokenNode>("Tilde", CSharpTokenNode.Null);
+		public static readonly TokenRole TildeRole = new TokenRole ("~");
 		
 		public CSharpTokenNode TildeToken {
 			get { return GetChildByRole (TildeRole); }

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/EventDeclaration.cs

@@ -30,6 +30,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class EventDeclaration : AttributedNode
 	{
+		public static readonly TokenRole EventKeywordRole = new TokenRole ("event");
+		
 		public override NodeType NodeType {
 			get { return NodeType.Member; }
 		}
@@ -68,6 +70,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class CustomEventDeclaration : MemberDeclaration
 	{
+		public static readonly TokenRole EventKeywordRole = new TokenRole ("event");
+		public static readonly TokenRole AddKeywordRole = new TokenRole ("add");
+		public static readonly TokenRole RemoveKeywordRole = new TokenRole ("remove");
+		
 		public static readonly Role<Accessor> AddAccessorRole = new Role<Accessor>("AddAccessor", Accessor.Null);
 		public static readonly Role<Accessor> RemoveAccessorRole = new Role<Accessor>("RemoveAccessor", Accessor.Null);
 		

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/FixedFieldDeclaration.cs

@@ -29,6 +29,7 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class FixedFieldDeclaration : AttributedNode
 	{
+		public static readonly TokenRole FixedKeywordRole = new TokenRole ("fixed");
 		public static readonly Role<FixedVariableInitializer> VariableRole = new Role<FixedVariableInitializer> ("FixedVariable");
 		
 		public override NodeType NodeType {
@@ -36,7 +37,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public CSharpTokenNode FixedToken {
-			get { return GetChildByRole (Roles.Keyword); }
+			get { return GetChildByRole (FixedKeywordRole); }
 		}
 
 		public AstType ReturnType {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/IndexerDeclaration.cs

@@ -31,6 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class IndexerDeclaration : MemberDeclaration
 	{
+		public static readonly TokenRole ThisKeywordRole = new TokenRole ("this");
 		public static readonly Role<Accessor> GetterRole = PropertyDeclaration.GetterRole;
 		public static readonly Role<Accessor> SetterRole = PropertyDeclaration.SetterRole;
 		

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/OperatorDeclaration.cs

@@ -71,19 +71,58 @@ namespace ICSharpCode.NRefactory.CSharp
 	
 	public class OperatorDeclaration : AttributedNode
 	{
-		public static readonly Role<CSharpTokenNode> OperatorTypeRole = new Role<CSharpTokenNode> ("OperatorType", CSharpTokenNode.Null);
-		public static readonly Role<CSharpTokenNode> OperatorKeywordRole = Roles.Keyword;
+		public static readonly TokenRole OperatorKeywordRole = new TokenRole ("operator");
+		
+		// Unary operators
+		public static readonly TokenRole LogicalNotRole = new TokenRole ("!");
+		public static readonly TokenRole OnesComplementRole = new TokenRole ("~");
+		public static readonly TokenRole IncrementRole = new TokenRole ("++");
+		public static readonly TokenRole DecrementRole = new TokenRole ("--");
+		public static readonly TokenRole TrueRole = new TokenRole ("true");
+		public static readonly TokenRole FalseRole = new TokenRole ("false");
+
+		// Unary and Binary operators
+		public static readonly TokenRole AdditionRole = new TokenRole ("+");
+		public static readonly TokenRole SubtractionRole = new TokenRole ("-");
+
+		// Binary operators
+		public static readonly TokenRole MultiplyRole = new TokenRole ("*");
+		public static readonly TokenRole DivisionRole = new TokenRole ("/");
+		public static readonly TokenRole ModulusRole = new TokenRole ("%");
+		public static readonly TokenRole BitwiseAndRole = new TokenRole ("&");
+		public static readonly TokenRole BitwiseOrRole = new TokenRole ("|");
+		public static readonly TokenRole ExclusiveOrRole = new TokenRole ("^");
+		public static readonly TokenRole LeftShiftRole = new TokenRole ("<<");
+		public static readonly TokenRole RightShiftRole = new TokenRole (">>");
+		public static readonly TokenRole EqualityRole = new TokenRole ("==");
+		public static readonly TokenRole InequalityRole = new TokenRole ("!=");
+		public static readonly TokenRole GreaterThanRole = new TokenRole (">");
+		public static readonly TokenRole LessThanRole = new TokenRole ("<");
+		public static readonly TokenRole GreaterThanOrEqualRole = new TokenRole (">=");
+		public static readonly TokenRole LessThanOrEqualRole = new TokenRole ("<=");
+		
+		public static readonly TokenRole ExplicitRole = new TokenRole ("explicit");
+		public static readonly TokenRole ImplicitRole = new TokenRole ("implicit");
 		
 		public OperatorType OperatorType {
 			get;
 			set;
 		}
 		
+		
 		public AstType ReturnType {
 			get { return GetChildByRole (Roles.Type); }
 			set { SetChildByRole (Roles.Type, value); }
 		}
 		
+		public CSharpTokenNode OperatorToken {
+			get { return GetChildByRole (OperatorKeywordRole); }
+		}
+		
+		public CSharpTokenNode OperatorTypeToken {
+			get { return GetChildByRole (GetRole (OperatorType)); }
+		}
+		
 		public CSharpTokenNode LParToken {
 			get { return GetChildByRole (Roles.LPar); }
 		}
@@ -109,6 +148,66 @@ namespace ICSharpCode.NRefactory.CSharp
 			return (OperatorType?)Mono.CSharp.Operator.GetType(methodName);
 		}
 		
+		public static TokenRole GetRole (OperatorType type)
+		{
+			switch (type) {
+			case OperatorType.LogicalNot:
+				return LogicalNotRole;
+			case OperatorType.OnesComplement:
+				return OnesComplementRole;
+			case OperatorType.Increment:
+				return IncrementRole;
+			case OperatorType.Decrement:
+				return DecrementRole;
+			case OperatorType.True:
+				return TrueRole;
+			case OperatorType.False:
+				return FalseRole;
+			
+			case OperatorType.Addition:
+				return AdditionRole;
+			case OperatorType.Subtraction:
+				return SubtractionRole;
+			
+			case OperatorType.Multiply:
+				return MultiplyRole;
+			case OperatorType.Division:
+				return DivisionRole;
+			case OperatorType.Modulus:
+				return ModulusRole;
+			case OperatorType.BitwiseAnd:
+				return BitwiseAndRole;
+			case OperatorType.BitwiseOr:
+				return BitwiseOrRole;
+			case OperatorType.ExclusiveOr:
+				return ExclusiveOrRole;
+			case OperatorType.LeftShift:
+				return LeftShiftRole;
+			case OperatorType.RightShift:
+				return RightShiftRole;
+			case OperatorType.Equality:
+				return EqualityRole;
+			case OperatorType.Inequality:
+				return InequalityRole;
+			case OperatorType.GreaterThan:
+				return GreaterThanRole;
+			case OperatorType.LessThan:
+				return LessThanRole;
+			case OperatorType.GreaterThanOrEqual:
+				return GreaterThanOrEqualRole;
+			case OperatorType.LessThanOrEqual:
+				return LessThanOrEqualRole;
+			
+			case OperatorType.Implicit:
+				return ImplicitRole;
+			case OperatorType.Explicit:
+				return ExplicitRole;
+			
+			default:
+				throw new System.ArgumentOutOfRangeException ();
+			}
+		}
+		
 		/// <summary>
 		/// Gets the method name for the operator type. ("op_Addition", "op_Implicit", etc.)
 		/// </summary>

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/ParameterDeclaration.cs

@@ -41,7 +41,10 @@ namespace ICSharpCode.NRefactory.CSharp
 	public class ParameterDeclaration : AstNode
 	{
 		public static readonly Role<AttributeSection> AttributeRole = AttributedNode.AttributeRole;
-		public static readonly Role<CSharpTokenNode> ModifierRole = new Role<CSharpTokenNode>("Modifier", CSharpTokenNode.Null);
+		public static readonly TokenRole RefModifierRole = new TokenRole("ref");
+		public static readonly TokenRole OutModifierRole = new TokenRole("out");
+		public static readonly TokenRole ParamsModifierRole = new TokenRole("params");
+		public static readonly TokenRole ThisModifierRole = new TokenRole("this");
 		
 		public override NodeType NodeType {
 			get {

ICSharpCode.NRefactory.CSharp/Ast/TypeMembers/PropertyDeclaration.cs

@@ -28,6 +28,8 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class PropertyDeclaration : MemberDeclaration
 	{
+		public static readonly TokenRole GetKeywordRole = new TokenRole ("get");
+		public static readonly TokenRole SetKeywordRole = new TokenRole ("set");
 		public static readonly Role<Accessor> GetterRole = new Role<Accessor>("Getter", Accessor.Null);
 		public static readonly Role<Accessor> SetterRole = new Role<Accessor>("Setter", Accessor.Null);
 		

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -41,12 +41,11 @@
     <DefineConstants>TRACE;FULL_AST</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugSymbols>false</DebugSymbols>
-    <DebugType>PdbOnly</DebugType>
+    <DebugType>none</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
-    <DebugType>Full</DebugType>
+    <DebugType>full</DebugType>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -327,6 +326,7 @@
     <Compile Include="Parser\mcs\module.cs" />
     <Compile Include="Parser\mcs\settings.cs" />
     <Compile Include="Parser\mcs\SourceMethodBuilder.cs" />
+    <Compile Include="Ast\TokenRole.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj">

ICSharpCode.NRefactory.Tests/CSharp/CSharpOutputVisitorTests.cs

@@ -70,11 +70,11 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void InlineCommentAtEndOfCondition()
 		{
 			IfElseStatement condition = new IfElseStatement();
-			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 1), 2), IfElseStatement.IfKeywordRole);
-			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 4), 1), IfElseStatement.Roles.LPar);
+			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 1)), IfElseStatement.IfKeywordRole);
+			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 4)), IfElseStatement.Roles.LPar);
 			condition.AddChild(new IdentifierExpression("cond", new TextLocation(1, 5)), IfElseStatement.ConditionRole);
 			condition.AddChild(new Comment(CommentType.MultiLine, new TextLocation(1, 9), new TextLocation(1, 14)) { Content = "a" }, IfElseStatement.Roles.Comment);
-			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 14), 1), IfElseStatement.Roles.RPar);
+			condition.AddChild(new CSharpTokenNode(new TextLocation(1, 14)), IfElseStatement.Roles.RPar);
 			condition.AddChild(new ReturnStatement(), IfElseStatement.TrueRole);
 			
 			AssertOutput("if (cond/*a*/)\n$return;\n", condition);

ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/PreprocessorDirectiveTests.cs

@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 			Assert.AreEqual(0, ns.Members.Count);
 			
 			Assert.AreEqual(new Role[] {
-			                	AstNode.Roles.Keyword,
+			                	NamespaceDeclaration.NamespaceKeywordRole,
 			                	AstNode.Roles.Identifier,
 			                	AstNode.Roles.LBrace,
 			                	AstNode.Roles.PreProcessorDirective,
@@ -83,7 +83,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 			Assert.AreEqual(0, ns.Members.Count);
 			
 			Assert.AreEqual(new Role[] {
-			                	AstNode.Roles.Keyword,
+			                	NamespaceDeclaration.NamespaceKeywordRole,
 			                	AstNode.Roles.Identifier,
 			                	AstNode.Roles.LBrace,
 			                	AstNode.Roles.PreProcessorDirective,
@@ -110,7 +110,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 			Assert.AreEqual(0, ns.Members.Count);
 			
 			Assert.AreEqual(new Role[] {
-			                	AstNode.Roles.Keyword,
+			                	NamespaceDeclaration.NamespaceKeywordRole,
 			                	AstNode.Roles.Identifier,
 			                	AstNode.Roles.LBrace,
 			                	AstNode.Roles.PreProcessorDirective,

ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/TypeDeclarationTests.cs

@@ -326,7 +326,7 @@ public abstract class MyClass : MyBase, Interface1, My.Test.Interface2
 			TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("enum MyEnum { A, }");
 			Assert.AreEqual(
 				new Role[] {
-					AstNode.Roles.Keyword,
+					TypeDeclaration.EnumKeywordRole,
 					AstNode.Roles.Identifier,
 					AstNode.Roles.LBrace,
 					TypeDeclaration.MemberRole,
@@ -341,7 +341,7 @@ public abstract class MyClass : MyBase, Interface1, My.Test.Interface2
 			TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("enum MyEnum { A, };");
 			Assert.AreEqual(
 				new Role[] {
-					AstNode.Roles.Keyword,
+					TypeDeclaration.EnumKeywordRole,
 					AstNode.Roles.Identifier,
 					AstNode.Roles.LBrace,
 					TypeDeclaration.MemberRole,
@@ -357,7 +357,7 @@ public abstract class MyClass : MyBase, Interface1, My.Test.Interface2
 			TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("enum MyEnum { A };");
 			Assert.AreEqual(
 				new Role[] {
-					AstNode.Roles.Keyword,
+					TypeDeclaration.EnumKeywordRole,
 					AstNode.Roles.Identifier,
 					AstNode.Roles.LBrace,
 					TypeDeclaration.MemberRole,

ICSharpCode.NRefactory/Role.cs

@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory
 	/// Represents the role a node plays within its parent.
 	/// All nodes with this role have type T.
 	/// </summary>
-	public sealed class Role<T> : Role where T : class
+	public class Role<T> : Role where T : class
 	{
 		readonly string name; // helps with debugging the AST
 		readonly T nullObject;