public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryExpression = node as QueryExpressionSyntax;
if (queryExpression != null)
{
var firstToken = queryExpression.FromClause.Expression.GetFirstToken(includeZeroWidth: true);
var lastToken = queryExpression.FromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, queryExpression.FromClause.FromKeyword, firstToken, lastToken);
for (int i = 0; i < queryExpression.Body.Clauses.Count; i++)
{
// if it is nested query expression
var fromClause = queryExpression.Body.Clauses[i] as FromClauseSyntax;
if (fromClause != null)
{
firstToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
lastToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, fromClause.FromKeyword, firstToken, lastToken);
}
}
// set alignment line for query expression
var baseToken = queryExpression.GetFirstToken(includeZeroWidth: true);
var endToken = queryExpression.GetLastToken(includeZeroWidth: true);
if (!baseToken.IsMissing && !baseToken.Equals(endToken))
{
var startToken = baseToken.GetNextToken(includeZeroWidth: true);
SetAlignmentBlockOperation(list, baseToken, startToken, endToken);
}
}
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
if (s_allowableKinds.Contains(node.Kind()))
{
AddChangeSignatureIndentOperation(list, node);
}
}
public override void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
if (node.IsKind(SyntaxKind.SimpleLambdaExpression) || node.IsKind(SyntaxKind.ParenthesizedLambdaExpression) || node.IsKind(SyntaxKind.AnonymousMethodExpression))
{
return;
}
nextOperation.Invoke(list);
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryExpression = node as QueryExpressionSyntax;
if (queryExpression != null)
{
AddSuppressWrappingIfOnSingleLineOperation(list, queryExpression.GetFirstToken(includeZeroWidth: true), queryExpression.GetLastToken(includeZeroWidth: true));
}
}
private void AddNextIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
if (_vbHelperFormattingRule == null)
{
base.AddIndentBlockOperations(list, node, optionSet, nextOperation);
return;
}
_vbHelperFormattingRule.AddIndentBlockOperations(list, node, optionSet, nextOperation);
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
AddInitializerSuppressOperations(list, node);
AddBraceSuppressOperations(list, node, lastToken);
AddStatementExceptBlockSuppressOperations(list, node);
AddSpecificNodesSuppressOperations(list, node);
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
if (!node.ContainsAnnotations)
{
return;
}
AddPropertyDeclarationSuppressOperations(list, node);
AddInitializerSuppressOperations(list, node);
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
AddBlockIndentationOperation(list, node, optionSet);
AddLabelIndentationOperation(list, node, optionSet);
AddSwitchIndentationOperation(list, node, optionSet);
AddEmbeddedStatementsIndentationOperation(list, node);
AddTypeParameterConstraintClauseOperation(list, node);
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
var bracePair = node.GetBracePair();
// don't put block indentation operation if the block only contains lambda expression body block
if (node.IsLambdaBodyBlock() || !bracePair.IsValidBracePair())
{
return;
}
if (optionSet.GetOption(CSharpFormattingOptions.OpenCloseBracesIndent))
{
AddIndentBlockOperation(list, bracePair.Item1, bracePair.Item1, bracePair.Item1.Span);
AddIndentBlockOperation(list, bracePair.Item2, bracePair.Item2, bracePair.Item2.Span);
}
}
public override void AddAlignTokensOperations(List<AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AlignTokensOperation> nextOperation)
{
nextOperation.Invoke(list);
var syntaxNode = node;
var bracePair = node.GetBracePair();
if (!bracePair.IsValidBracePair())
{
return;
}
if (syntaxNode.IsLambdaBodyBlock() ||
node is InitializerExpressionSyntax)
{
AddAlignIndentationOfTokensToFirstTokenOfBaseTokenLineOperation(list, syntaxNode, bracePair.Item1, SpecializedCollections.SingletonEnumerable((SyntaxToken)bracePair.Item2));
}
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
AddBraceSuppressOperations(list, node);
AddStatementExceptBlockSuppressOperations(list, node);
AddSpecificNodesSuppressOperations(list, node);
if (!optionSet.GetOption(CSharpFormattingOptions.WrappingPreserveSingleLine))
{
RemoveSuppressOperationForBlock(list, node);
}
if (!optionSet.GetOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine))
{
RemoveSuppressOperationForStatementMethodDeclaration(list, node);
}
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
// for the common node itself, return absolute indentation
if (_commonNode == node)
{
// TODO: If the first line of the span includes a node, we want to align with the position of that node
// in the primary buffer. That's what Dev12 does for C#, but it doesn't match Roslyn's current model
// of each statement being formatted independently with respect to it's parent.
list.Add(new IndentBlockOperation(_token1, _token2, _span, _baseIndentation, IndentBlockOption.AbsolutePosition));
}
else if (node.Span.Contains(_span))
{
// any node bigger than our span is ignored.
return;
}
// Add everything to the list.
AddNextIndentBlockOperations(list, node, optionSet, nextOperation);
// Filter out everything that encompasses our span.
AdjustIndentBlockOperation(list);
}
public override void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryClause = node as QueryClauseSyntax;
if (queryClause != null)
{
var firstToken = queryClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, queryClause.GetLastToken(includeZeroWidth: true));
}
var selectOrGroupClause = node as SelectOrGroupClauseSyntax;
if (selectOrGroupClause != null)
{
var firstToken = selectOrGroupClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, selectOrGroupClause.GetLastToken(includeZeroWidth: true));
}
var continuation = node as QueryContinuationSyntax;
if (continuation != null)
{
AddAnchorIndentationOperation(list, continuation.IntoKeyword, continuation.GetLastToken(includeZeroWidth: true));
}
}
public override void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
if (node is QueryExpressionSyntax queryExpression)
{
AddIndentBlockOperationsForFromClause(list, queryExpression.FromClause);
foreach (var queryClause in queryExpression.Body.Clauses)
{
// if it is nested query expression
if (queryClause is FromClauseSyntax fromClause)
{
AddIndentBlockOperationsForFromClause(list, fromClause);
}
}
// set alignment line for query expression
var baseToken = queryExpression.GetFirstToken(includeZeroWidth: true);
var endToken = queryExpression.GetLastToken(includeZeroWidth: true);
if (!baseToken.IsMissing && !baseToken.Equals(endToken))
{
var startToken = baseToken.GetNextToken(includeZeroWidth: true);
SetAlignmentBlockOperation(list, baseToken, startToken, endToken);
}
}
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
// don't suppress anything
}
public override void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryClause = node as QueryClauseSyntax;
if (queryClause != null)
{
var firstToken = queryClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, queryClause.GetLastToken(includeZeroWidth: true));
}
var selectOrGroupClause = node as SelectOrGroupClauseSyntax;
if (selectOrGroupClause != null)
{
var firstToken = selectOrGroupClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, selectOrGroupClause.GetLastToken(includeZeroWidth: true));
}
var continuation = node as QueryContinuationSyntax;
if (continuation != null)
{
AddAnchorIndentationOperation(list, continuation.IntoKeyword, continuation.GetLastToken(includeZeroWidth: true));
}
}
public override void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
if (node.IsKind(SyntaxKind.SimpleLambdaExpression) || node.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
if (node.IsKind(SyntaxKind.AnonymousMethodExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
if (node is BlockSyntax block)
{
// if it is not nested block, then its anchor will be first token that this block is
// associated with. otherwise, "{" of block is the anchor token its children would follow
if (block.Parent == null || block.Parent is BlockSyntax)
{
AddAnchorIndentationOperation(list, block);
return;
}
else
{
AddAnchorIndentationOperation(list,
block.Parent.GetFirstToken(includeZeroWidth: true),
block.GetLastToken(includeZeroWidth: true));
return;
}
}
switch (node)
{
case StatementSyntax statement:
AddAnchorIndentationOperation(list, statement);
return;
case UsingDirectiveSyntax usingNode:
AddAnchorIndentationOperation(list, usingNode);
return;
case NamespaceDeclarationSyntax namespaceNode:
AddAnchorIndentationOperation(list, namespaceNode);
return;
case TypeDeclarationSyntax typeNode:
AddAnchorIndentationOperation(list, typeNode);
return;
case MemberDeclarationSyntax memberDeclNode:
AddAnchorIndentationOperation(list, memberDeclNode);
return;
case AccessorDeclarationSyntax accessorDeclNode:
AddAnchorIndentationOperation(list, accessorDeclNode);
return;
case CSharpSyntaxNode switchExpressionArm when switchExpressionArm.IsKind(SyntaxKindEx.SwitchExpressionArm):
// The expression in a switch expression arm should be anchored to the beginning of the arm
// ```
// e switch
// {
// pattern:
// expression,
// ```
// We will keep the relative position of `expression` relative to `pattern:`. It will format to:
// ```
// e switch
// {
// pattern:
// expression,
// ```
AddAnchorIndentationOperation(list, switchExpressionArm);
return;
}
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
base.AddSuppressOperations(list, node, optionSet, nextOperation);
// remove suppression rules for array and collection initializer
if (node.IsInitializerForArrayOrCollectionCreationExpression())
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInObjectInitializers))
{
// remove any suppression operation
list.RemoveAll(s_predicate);
}
else
{
// remove only space suppression operation.
for (var i = 0; i < list.Count; i++)
{
var operation = list[i];
if (operation.Option.IsMaskOn(SuppressOption.NoSpacing))
{
list[i] = FormattingOperations.CreateSuppressOperation(operation.StartToken, operation.EndToken, operation.Option & ~SuppressOption.NoSpacing);
}
}
}
}
}
public override void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
var block = node as BlockSyntax;
if (block != null && block.Parent is BlockSyntax)
{
// if it is not nested block, then its anchor will be first token that this block is
// associated with. otherwise, "{" of block is the anchor token its children would follow
var startToken = block.GetFirstToken(includeZeroWidth: true);
var lastToken = block.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var statement = node as StatementSyntax;
if (statement != null)
{
var startToken = statement.GetFirstToken(includeZeroWidth: true);
var lastToken = statement.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var usingNode = node as UsingDirectiveSyntax;
if (usingNode != null)
{
var startToken = usingNode.GetFirstToken(includeZeroWidth: true);
var lastToken = usingNode.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var namespaceNode = node as NamespaceDeclarationSyntax;
if (namespaceNode != null)
{
var startToken = namespaceNode.GetFirstToken(includeZeroWidth: true);
var lastToken = namespaceNode.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var typeNode = node as TypeDeclarationSyntax;
if (typeNode != null)
{
var startToken = typeNode.GetFirstToken(includeZeroWidth: true);
var lastToken = typeNode.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var memberDeclNode = node as MemberDeclarationSyntax;
if (memberDeclNode != null)
{
var startToken = memberDeclNode.GetFirstToken(includeZeroWidth: true);
var lastToken = memberDeclNode.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
var accessorDeclNode = node as AccessorDeclarationSyntax;
if (accessorDeclNode != null)
{
var startToken = accessorDeclNode.GetFirstToken(includeZeroWidth: true);
var lastToken = accessorDeclNode.GetLastToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, startToken, lastToken);
return;
}
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
AddBraceSuppressOperations(list, node);
AddStatementExceptBlockSuppressOperations(list, node);
AddSpecificNodesSuppressOperations(list, node);
if (!optionSet.GetOption(CSharpFormattingOptions.LeaveBlockSingleLine))
{
RemoveSuppressOperationForBlock(list, node);
}
if (!optionSet.GetOption(CSharpFormattingOptions.LeaveStatementMethodDeclarationSameLine))
{
RemoveSuppressOperationForStatementMethodDeclaration(list, node);
}
}
/// <summary>
/// Align all the wrapped parts of the expression with the token after 'return'.
/// That way we get:
///
/// return a == obj.a &&
/// b == obj.b &&
/// ...
/// </summary>
public override void AddIndentBlockOperations(
List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
if (_syntaxFacts.IsReturnStatement(node))
{
var expr = _syntaxFacts.GetExpressionOfReturnStatement(node);
if (expr?.ChildNodesAndTokens().Count > 1)
{
list.Add(FormattingOperations.CreateRelativeIndentBlockOperation(
expr.GetFirstToken(),
expr.GetFirstToken().GetNextToken(),
node.GetLastToken(),
indentationDelta: 0,
option: IndentBlockOption.RelativePosition));
return;
}
}
nextOperation.Invoke(list);
}
public override void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
if (node.IsKind(SyntaxKind.SimpleLambdaExpression) || node.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
if (node.IsKind(SyntaxKind.AnonymousMethodExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
if (node is BlockSyntax block)
{
// if it is not nested block, then its anchor will be first token that this block is
// associated with. otherwise, "{" of block is the anchor token its children would follow
if (block.Parent == null || block.Parent is BlockSyntax)
{
AddAnchorIndentationOperation(list, block);
return;
}
else
{
AddAnchorIndentationOperation(list,
block.Parent.GetFirstToken(includeZeroWidth: true),
block.GetLastToken(includeZeroWidth: true));
return;
}
}
switch (node)
{
case StatementSyntax statement:
AddAnchorIndentationOperation(list, statement);
return;
case UsingDirectiveSyntax usingNode:
AddAnchorIndentationOperation(list, usingNode);
return;
case NamespaceDeclarationSyntax namespaceNode:
AddAnchorIndentationOperation(list, namespaceNode);
return;
case TypeDeclarationSyntax typeNode:
AddAnchorIndentationOperation(list, typeNode);
return;
case MemberDeclarationSyntax memberDeclNode:
AddAnchorIndentationOperation(list, memberDeclNode);
return;
case AccessorDeclarationSyntax accessorDeclNode:
AddAnchorIndentationOperation(list, accessorDeclNode);
return;
}
}
public void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public void AddAlignTokensOperations(List <AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AlignTokensOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public override void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
// these nodes should be from syntax tree from ITextSnapshot.
Contract.Requires(node.SyntaxTree != null);
Contract.Requires(node.SyntaxTree.GetText() != null);
nextOperation.Invoke(list);
ReplaceCaseIndentationRules(list, node);
if (node is BaseParameterListSyntax ||
node is TypeArgumentListSyntax ||
node is TypeParameterListSyntax ||
node.IsKind(SyntaxKind.Interpolation))
{
AddIndentBlockOperations(list, node);
return;
}
var argument = node as BaseArgumentListSyntax;
if (argument != null &&
argument.Parent.Kind() != SyntaxKind.ThisConstructorInitializer &&
!IsBracketedArgumentListMissingBrackets(argument as BracketedArgumentListSyntax))
{
AddIndentBlockOperations(list, argument);
return;
}
// only valid if the user has started to actually type a constructor initializer
var constructorInitializer = node as ConstructorInitializerSyntax;
if (constructorInitializer != null &&
constructorInitializer.ArgumentList.OpenParenToken.Kind() != SyntaxKind.None &&
!constructorInitializer.ThisOrBaseKeyword.IsMissing)
{
var text = node.SyntaxTree.GetText();
// 3 different cases
// first case : this or base is the first token on line
// second case : colon is the first token on line
var colonIsFirstTokenOnLine = !constructorInitializer.ColonToken.IsMissing && constructorInitializer.ColonToken.IsFirstTokenOnLine(text);
var thisOrBaseIsFirstTokenOnLine = !constructorInitializer.ThisOrBaseKeyword.IsMissing && constructorInitializer.ThisOrBaseKeyword.IsFirstTokenOnLine(text);
if (colonIsFirstTokenOnLine || thisOrBaseIsFirstTokenOnLine)
{
list.Add(FormattingOperations.CreateRelativeIndentBlockOperation(
constructorInitializer.ThisOrBaseKeyword,
constructorInitializer.ArgumentList.OpenParenToken.GetNextToken(includeZeroWidth: true),
constructorInitializer.ArgumentList.CloseParenToken.GetPreviousToken(includeZeroWidth: true),
indentationDelta: 1,
option: IndentBlockOption.RelativePosition));
}
else
{
// third case : none of them are the first token on the line
AddIndentBlockOperations(list, constructorInitializer.ArgumentList);
}
}
}
public override void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
if (node.IsKind(SyntaxKind.SimpleLambdaExpression) || node.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
if (node.IsKind(SyntaxKind.AnonymousMethodExpression))
{
AddAnchorIndentationOperation(list, node);
return;
}
var block = node as BlockSyntax;
if (block != null)
{
// if it is not nested block, then its anchor will be first token that this block is
// associated with. otherwise, "{" of block is the anchor token its children would follow
if (block.Parent == null || block.Parent is BlockSyntax)
{
AddAnchorIndentationOperation(list, block);
return;
}
else
{
AddAnchorIndentationOperation(list,
block.Parent.GetFirstToken(includeZeroWidth: true),
block.GetLastToken(includeZeroWidth: true));
return;
}
}
var statement = node as StatementSyntax;
if (statement != null)
{
AddAnchorIndentationOperation(list, statement);
return;
}
var usingNode = node as UsingDirectiveSyntax;
if (usingNode != null)
{
AddAnchorIndentationOperation(list, usingNode);
return;
}
var namespaceNode = node as NamespaceDeclarationSyntax;
if (namespaceNode != null)
{
AddAnchorIndentationOperation(list, namespaceNode);
return;
}
var typeNode = node as TypeDeclarationSyntax;
if (typeNode != null)
{
AddAnchorIndentationOperation(list, typeNode);
return;
}
var memberDeclNode = node as MemberDeclarationSyntax;
if (memberDeclNode != null)
{
AddAnchorIndentationOperation(list, memberDeclNode);
return;
}
var accessorDeclNode = node as AccessorDeclarationSyntax;
if (accessorDeclNode != null)
{
AddAnchorIndentationOperation(list, accessorDeclNode);
return;
}
}
public override void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
return;
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
/// <returns>BUGGY: true if redo last action</returns>
protected bool invokeAction(DelegateEventArgs e)
{
GameBoard.Statistics.ActionChoosen[e.ChoosenAction] = System.Convert.ToInt32(GameBoard.Statistics.ActionChoosen[e.ChoosenAction]) + 1;
switch (e.ChoosenAction)
{
case eActionType.Move:
{
OnMove();
break;
}
case eActionType.BuyHouse:
{
((HouseField)e.Fields[0]).Buy(this);
break;
}
case eActionType.PayRent:
{
((HouseField)e.Fields[0]).PayRent(this);
break;
}
case eActionType.GiveUp:
{
OnBankrupt();
break;
}
case eActionType.UpgradeHouse:
{
((HouseField)e.Fields[0]).Upgrade();
break;
}
case eActionType.LoseTurn:
{
RaiseJail(eActionType.LoseTurn);
break;
}
case eActionType.GoToField:
{
MoveTo(e.Fields[0], false);
break;
}
case eActionType.JumpToField:
case eActionType.JumpToRelativField:
{
MoveTo(e.Fields[0], true);
break;
}
case eActionType.JumpToJail:
{
GameBoard.JailField.GoToJail(this);
RaiseJail(eActionType.JumpToJail);
break;
}
case eActionType.PayToStack:
{
TransferMoney(GameBoard.Wundertuete, e.Cash);
break;
}
case eActionType.CollectStack:
{
GameBoard.Wundertuete.TransferMoney(this, e.Cash);
break;
}
case eActionType.CashToBank:
{
TransferMoney(GameBoard.BANK, e.Cash);
break;
}
case eActionType.CashFromBank:
{
GameBoard.BANK.TransferMoney(this, e.Cash);
break;
}
case eActionType.CashToPlayer:
{
TransferMoney(e.Players[0], e.Cash);
break;
}
case eActionType.CashFromPlayer:
{
e.Players[0].TransferMoney(this, e.Cash);
break;
}
case eActionType.CashFromAll:
{
foreach (var p in GameBoard.PlayerRank)
{
if (p.IsPlayering)
{
p.TransferMoney(this, e.Cash);
}
}
break;
}
case eActionType.PayPerHouse:
{
foreach (var house in OwnFields)
{
TransferMoney(GameBoard.BANK, e.Cash);
}
break;
}
case eActionType.AddMove:
{
//BUGGY!
NextAction.Clear();
NextAction.Enqueue(eActionType.Move);
break;
}
case eActionType.Card_UseFreeParking:
{
RaiseChance(eActionType.Card_UseFreeParking, new object[] { e.Fields[0] });
if (!CheatAlwaysRentFree)
{
GameBoard.FreeParkingOwner = GameBoard.BANK;
}
break;
}
case eActionType.Card_GetFreeParking:
{
GameBoard.FreeParkingOwner = this;
break;
}
case eActionType.Card_UseFreeJail:
{
RaiseChance(eActionType.Card_UseFreeJail, new object[] { GameBoard.JailField });
if (!CheatAlwaysJailFree)
{
GameBoard.FreeParkingOwner = GameBoard.BANK;
}
break;
}
case eActionType.Card_GetFreeJail:
{
GameBoard.FreeJailOwner = this;
break;
}
case eActionType.Pass:
case eActionType.None:
{
break;
}
case eActionType.CreditForHouse:
{
var h = (HouseField)e.Fields[0];
if (h.Owner.Equals(this))
{
h.TakeForCredit();
}
// Redo Last Action!
return(true);
}
case eActionType.CreditReleaseHouse:
{
var h = (HouseField)e.Fields[0];
if (h.Owner.Equals(this))
{
h.RemoveCredit();
}
// Redo Last Action!
return(true);
}
case eActionType.IncreaseFixedDeposite:
{
RaiseIncreaseFixedDeposite(e.Cash);
return(true);
}
case eActionType.TerminateFixedDeposite:
{
RaiseTerminateFixedDeposite();
return(true);
}
default:
{
throw new System.NotImplementedException(e.ChoosenAction.ToString());
}
}
return(false);
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
// don't suppress anything
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
SuppressVariableDeclaration(list, node, optionSet);
}
public override void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
AddAlignmentBlockOperation(list, node, optionSet);
AddBlockIndentationOperation(list, node, optionSet);
AddLabelIndentationOperation(list, node, optionSet);
AddSwitchIndentationOperation(list, node, optionSet);
AddEmbeddedStatementsIndentationOperation(list, node);
AddTypeParameterConstraintClauseOperation(list, node);
}
public override void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
var bracePair = node.GetBracePair();
// don't put block indentation operation if the block only contains lambda expression body block
if (node.IsLambdaBodyBlock() || !bracePair.IsValidBracePair())
{
return;
}
if (optionSet.GetOption(CSharpFormattingOptions.IndentBraces))
{
AddIndentBlockOperation(list, bracePair.Item1, bracePair.Item1, bracePair.Item1.Span);
AddIndentBlockOperation(list, bracePair.Item2, bracePair.Item2, bracePair.Item2.Span);
}
}
public void Start(NextAction fn)
{
GetNext = fn;
StartTick();
instance.BroadcastEvent("start");
}
public void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
}
public override void AddAlignTokensOperations(List <AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AlignTokensOperation> nextOperation)
{
nextOperation.Invoke(list);
var syntaxNode = node;
var bracePair = node.GetBracePair();
if (!bracePair.IsValidBracePair())
{
return;
}
if (syntaxNode.IsLambdaBodyBlock() ||
node is InitializerExpressionSyntax)
{
AddAlignIndentationOfTokensToFirstTokenOfBaseTokenLineOperation(list, syntaxNode, bracePair.Item1, SpecializedCollections.SingletonEnumerable((SyntaxToken)bracePair.Item2));
}
}
public override void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
switch (node)
{
case QueryClauseSyntax queryClause:
{
var firstToken = queryClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, queryClause.GetLastToken(includeZeroWidth: true));
return;
}
case SelectOrGroupClauseSyntax selectOrGroupClause:
{
var firstToken = selectOrGroupClause.GetFirstToken(includeZeroWidth: true);
AddAnchorIndentationOperation(list, firstToken, selectOrGroupClause.GetLastToken(includeZeroWidth: true));
return;
}
case QueryContinuationSyntax continuation:
AddAnchorIndentationOperation(list, continuation.IntoKeyword, continuation.GetLastToken(includeZeroWidth: true));
return;
}
}
public override void AddAlignTokensOperations(List<AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AlignTokensOperation> nextOperation)
{
base.AddAlignTokensOperations(list, node, optionSet, nextOperation);
if (optionSet.GetOption(SmartIndent, node.Language) == IndentStyle.Block)
{
var bracePair = node.GetBracePair();
if (bracePair.IsValidBracePair())
{
AddAlignIndentationOfTokensToBaseTokenOperation(list, node, bracePair.Item1, SpecializedCollections.SingletonEnumerable(bracePair.Item2), AlignTokensOption.AlignIndentationOfTokensToFirstTokenOfBaseTokenLine);
}
}
}
public override void AddAnchorIndentationOperations(List <AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AnchorIndentationOperation> nextOperation)
{
if (node.IsKind(SyntaxKind.SimpleLambdaExpression) || node.IsKind(SyntaxKind.ParenthesizedLambdaExpression) || node.IsKind(SyntaxKind.AnonymousMethodExpression))
{
return;
}
nextOperation.Invoke(list);
}
public void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
}
public void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
base.AddSuppressOperations(list, node, lastToken, optionSet, nextOperation);
// remove suppression rules for array and collection initializer
if (node.IsInitializerForArrayOrCollectionCreationExpression())
{
// remove any suppression operation
list.RemoveAll(s_predicate);
}
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
// these nodes should be from syntax tree from ITextSnapshot.
Contract.Requires(node.SyntaxTree != null);
Contract.Requires(node.SyntaxTree.GetText() != null);
nextOperation.Invoke(list);
ReplaceCaseIndentationRules(list, node);
if (node is BaseParameterListSyntax ||
node is TypeArgumentListSyntax ||
node is TypeParameterListSyntax ||
node.IsKind(SyntaxKind.Interpolation))
{
AddIndentBlockOperations(list, node);
return;
}
var argument = node as BaseArgumentListSyntax;
if (argument != null && argument.Parent.Kind() != SyntaxKind.ThisConstructorInitializer)
{
AddIndentBlockOperations(list, argument);
return;
}
var constructorInitializer = node as ConstructorInitializerSyntax;
if (constructorInitializer != null && constructorInitializer.ArgumentList.OpenParenToken.Kind() != SyntaxKind.None)
{
var text = node.SyntaxTree.GetText();
// 3 different cases
// first case : this or base is the first token on line
// second case : colon is the first token on line
var colonIsFirstTokenOnLine = !constructorInitializer.ColonToken.IsMissing && constructorInitializer.ColonToken.IsFirstTokenOnLine(text);
var thisOrBaseIsFirstTokenOnLine = !constructorInitializer.ThisOrBaseKeyword.IsMissing && constructorInitializer.ThisOrBaseKeyword.IsFirstTokenOnLine(text);
if (colonIsFirstTokenOnLine || thisOrBaseIsFirstTokenOnLine)
{
list.Add(FormattingOperations.CreateRelativeIndentBlockOperation(
constructorInitializer.ThisOrBaseKeyword,
constructorInitializer.ArgumentList.OpenParenToken.GetNextToken(includeZeroWidth: true),
constructorInitializer.ArgumentList.CloseParenToken.GetPreviousToken(includeZeroWidth: true),
indentationDelta: 1,
option: IndentBlockOption.RelativePosition));
}
else
{
// third case : none of them are the first token on the line
AddIndentBlockOperations(list, constructorInitializer.ArgumentList);
}
}
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
if (!node.ContainsAnnotations)
{
return;
}
AddPropertyDeclarationSuppressOperations(list, node);
AddInitializerSuppressOperations(list, node);
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
AddBraceSuppressOperations(list, node, lastToken);
AddStatementExceptBlockSuppressOperations(list, node);
AddSpecificNodesSuppressOperations(list, node);
if (!optionSet.GetOption(CSharpFormattingOptions.WrappingPreserveSingleLine))
{
RemoveSuppressOperationForBlock(list, node);
}
if (!optionSet.GetOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine))
{
RemoveSuppressOperationForStatementMethodDeclaration(list, node);
}
}
public void AddAnchorIndentationOperations(List<AnchorIndentationOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AnchorIndentationOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public override void AddAlignTokensOperations(List <AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <AlignTokensOperation> nextOperation)
{
base.AddAlignTokensOperations(list, node, optionSet, nextOperation);
if (optionSet.GetOption(SmartIndent, node.Language) == IndentStyle.Block)
{
var bracePair = node.GetBracePair();
if (bracePair.IsValidBracePair())
{
AddAlignIndentationOfTokensToBaseTokenOperation(list, node, bracePair.Item1, SpecializedCollections.SingletonEnumerable(bracePair.Item2), AlignTokensOption.AlignIndentationOfTokensToFirstTokenOfBaseTokenLine);
}
}
}
public void AddAlignTokensOperations(List<AlignTokensOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<AlignTokensOperation> nextOperation)
{
nextOperation.Invoke(list);
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
base.AddSuppressOperations(list, node, optionSet, nextOperation);
// remove suppression rules for array and collection initializer
if (node.IsInitializerForArrayOrCollectionCreationExpression())
{
// remove any suppression operation
list.RemoveAll(s_predicate);
}
}
public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
SuppressVariableDeclaration(list, node, optionSet);
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
AddInitializerSuppressOperations(list, node);
AddBraceSuppressOperations(list, node, lastToken);
AddStatementExceptBlockSuppressOperations(list, node);
AddSpecificNodesSuppressOperations(list, node);
}
public override void AddSuppressOperations(List <SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken, OptionSet optionSet, NextAction <SuppressOperation> nextOperation)
{
nextOperation.Invoke(list);
if (node is QueryExpressionSyntax queryExpression)
{
AddSuppressWrappingIfOnSingleLineOperation(list, queryExpression.GetFirstToken(includeZeroWidth: true), queryExpression.GetLastToken(includeZeroWidth: true));
}
}
public override void AddIndentBlockOperations(List <IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction <IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryExpression = node as QueryExpressionSyntax;
if (queryExpression != null)
{
var firstToken = queryExpression.FromClause.Expression.GetFirstToken(includeZeroWidth: true);
var lastToken = queryExpression.FromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, queryExpression.FromClause.FromKeyword, firstToken, lastToken);
for (int i = 0; i < queryExpression.Body.Clauses.Count; i++)
{
// if it is nested query expression
var fromClause = queryExpression.Body.Clauses[i] as FromClauseSyntax;
if (fromClause != null)
{
firstToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
lastToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, fromClause.FromKeyword, firstToken, lastToken);
}
}
// set alignment line for query expression
var baseToken = queryExpression.GetFirstToken(includeZeroWidth: true);
var endToken = queryExpression.GetLastToken(includeZeroWidth: true);
if (!baseToken.IsMissing && !baseToken.Equals(endToken))
{
var startToken = baseToken.GetNextToken(includeZeroWidth: true);
SetAlignmentBlockOperation(list, baseToken, startToken, endToken);
}
}
}
