/// <summary>Only call from within a lock.</summary>
private NextOperation TryStartNextOrTryComplete()
{
if (reachedEndOfEnumerator | cancelFurtherEnumeration)
{
return(TryComplete());
}
var taskIndex = startedTaskCount;
isCallingMoveNextOrCurrent = true;
try
{
reachedEndOfEnumerator = !source.MoveNext();
}
catch (Exception ex)
{
startedTaskCount++;
completedTaskCount++;
completedTasks[taskIndex] = Task.FromException <T>(ex);
reachedEndOfEnumerator = true;
}
finally
{
isCallingMoveNextOrCurrent = false;
}
if (reachedEndOfEnumerator)
{
return(TryComplete());
}
startedTaskCount++;
Task <T> task;
isCallingMoveNextOrCurrent = true;
try
{
// Even though MoveNext may have caused cancelFurtherEnumeration to become true, assume that
// the task is already started even if we don't access Current and that therefore we should
// observe it.
task = source.Current;
}
catch (Exception ex)
{
task = Task.FromException <T>(ex);
}
finally
{
isCallingMoveNextOrCurrent = false;
}
if (task is null)
{
task = Task.FromException <T>(new InvalidOperationException("The source task enumerator returned a null instance."));
}
return(NextOperation.Subscribe(task, taskIndex));
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (previousToken.Kind() == SyntaxKind.CommaToken && s_allowableKinds.Contains(previousToken.Parent.Kind()))
{
return FormattingOperations.CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
return base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (previousToken.Parent is StructuredTriviaSyntax || currentToken.Parent is StructuredTriviaSyntax)
{
return null;
}
return nextOperation.Invoke();
}
public AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (IsAfterEndRegionBeforeMethodDeclaration((SyntaxToken)previousToken, (SyntaxToken)currentToken))
{
return FormattingOperations.CreateAdjustNewLinesOperation(2, AdjustNewLinesOption.ForceLines);
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
var operation = base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
if (operation != null)
{
return s_preserveLine;
}
return operation;
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
if (previousToken.Parent is StructuredTriviaSyntax || currentToken.Parent is StructuredTriviaSyntax)
{
// this doesn't take care of all cases where tokens belong to structured trivia. this is only for cases we care
return GetAdjustSpacesOperation(previousToken, currentToken, nextOperation);
}
return nextOperation.Invoke();
}
private void DoNextOperation(NextOperation nextOperation)
{
if (nextOperation.IsSubscribe(out var task, out var taskIndex))
{
task.ContinueWith(OnTaskCompleted, state: taskIndex, TaskContinuationOptions.ExecuteSynchronously);
}
else if (nextOperation.IsComplete(out var canceled, out var completedTasks))
{
Complete(canceled, completedTasks);
}
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
// * <End Of File> case for C#, make sure we don't insert new line between * and <End of
// File> tokens.
if (currentToken.CSharpKind() == SyntaxKind.EndOfFileToken)
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
return nextOperation.Invoke();
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
// * <End Of File) case
// for C#, make sure we have nothing between these two tokens
if (currentToken.CSharpKind() == SyntaxKind.EndOfFileToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
return nextOperation.Invoke();
}
private TResult GetContinuedOperations <TResult>(int index, SyntaxToken token1, SyntaxToken token2, IOperationHolder <TResult> funcCache)
{
// If we have no remaining handlers to execute, then we'll execute our last handler
if (index >= _formattingRules.Count)
{
return(default(TResult));
}
else
{
// Call the handler at the index, passing a continuation that will come back to here with index + 1
var continuation = new NextOperation <TResult>(index + 1, token1, token2, funcCache);
return(funcCache.NextOperation(index, token1, token2, continuation));
}
}
private bool SpindelAus(string inPPEventName)
{
var spindel_jetzt = CurrentOperation.GetDataText("SPINDLE_ROT") ?? "NONE";
var spindel_nachher = NextOperation?.GetDataText("SPINDLE_ROT") ?? "NONE";
if (spindel_jetzt != spindel_nachher)
{
SPINDLE.Value = 5.0;
}
else
{
SPINDLE.DataVoid(); // #bloc = CLS,[SPINDLE]
}
return(true);
}
public AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
// case: insert blank line in empty method body.
if (previousToken.Kind() == SyntaxKind.OpenBraceToken &&
currentToken.Kind() == SyntaxKind.CloseBraceToken)
{
if (currentToken.Parent.Kind() == SyntaxKind.Block &&
currentToken.Parent.Parent.Kind() == SyntaxKind.MethodDeclaration)
{
return FormattingOperations.CreateAdjustNewLinesOperation(2, AdjustNewLinesOption.ForceLines);
}
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(
SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (previousToken.RawKind == 0 || currentToken.RawKind == 0)
{
nextOperation.Invoke();
}
var betweenMembersAndUsingsOperation = GetAdjustNewLinesOperationBetweenMembersAndUsings(previousToken, currentToken);
if (betweenMembersAndUsingsOperation != null)
{
return betweenMembersAndUsingsOperation;
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (currentToken.Parent != null)
{
var currentTokenParentParent = currentToken.Parent.Parent;
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null &&
(currentTokenParentParent.Kind() == SyntaxKind.SimpleLambdaExpression ||
currentTokenParentParent.Kind() == SyntaxKind.ParenthesizedLambdaExpression ||
currentTokenParentParent.Kind() == SyntaxKind.AnonymousMethodExpression))
{
return FormattingOperations.CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
}
return nextOperation.Invoke();
}
private AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, NextOperation<AdjustSpacesOperation> nextOperation)
{
if (previousToken.CSharpKind() == SyntaxKind.HashToken && SyntaxFacts.IsPreprocessorKeyword(currentToken.CSharpKind()))
{
return CreateAdjustSpacesOperation(space: 0, option: AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
if (previousToken.CSharpKind() == SyntaxKind.RegionKeyword && currentToken.CSharpKind() == SyntaxKind.EndOfDirectiveToken)
{
return CreateAdjustSpacesOperation(space: 1, option: AdjustSpacesOption.PreserveSpaces);
}
if (currentToken.CSharpKind() == SyntaxKind.EndOfDirectiveToken)
{
return CreateAdjustSpacesOperation(space: 0, option: AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
return nextOperation.Invoke();
}
/// <summary>Only call from within a lock.</summary>
private NextOperation TryComplete()
{
if (completionHandled || completedTaskCount != startedTaskCount)
{
return(NextOperation.None);
}
try
{
source.Dispose();
}
catch (Exception ex)
{
var taskIndex = startedTaskCount;
startedTaskCount++;
completedTaskCount++;
completedTasks[taskIndex] = Task.FromException <T>(ex);
}
completionHandled = true;
return(NextOperation.Complete(canceled: !reachedEndOfEnumerator, completedTasks.MoveToArraySegment()));
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
// for extract method case, for a hybrid case, don't force rule, but preserve user style
var operation = base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
if (operation == null)
{
return null;
}
if (operation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
{
return FormattingOperations.CreateAdjustNewLinesOperation(operation.Line, AdjustNewLinesOption.PreserveLines);
}
if (operation.Option != AdjustNewLinesOption.ForceLines)
{
return operation;
}
if (previousToken.RawKind == (int)SyntaxKind.OpenBraceToken)
{
return operation;
}
if (previousToken.BetweenFieldAndNonFieldMember(currentToken))
{
// make sure to have at least 2 line breaks between field and other members except field
return FormattingOperations.CreateAdjustNewLinesOperation(2, AdjustNewLinesOption.PreserveLines);
}
if (previousToken.HasHybridTriviaBetween(currentToken))
{
return FormattingOperations.CreateAdjustNewLinesOperation(operation.Line, AdjustNewLinesOption.PreserveLines);
}
return operation;
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
// no line operation. no line changes what so ever
var lineOperation = base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
if (lineOperation != null)
{
// ignore force if same line option
if (lineOperation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
{
return null;
}
// basically means don't ever put new line if there isn't already one, but do
// indentation.
return FormattingOperations.CreateAdjustNewLinesOperation(line: 0, option: AdjustNewLinesOption.PreserveLines);
}
return null;
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
var spaceOperation = base.GetAdjustSpacesOperation(previousToken, currentToken, optionSet, nextOperation);
// if there is force space operation, convert it to ForceSpaceIfSingleLine operation.
// (force space basically means remove all line breaks)
if (spaceOperation != null && spaceOperation.Option == AdjustSpacesOption.ForceSpaces)
{
return(FormattingOperations.CreateAdjustSpacesOperation(spaceOperation.Space, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
return(spaceOperation);
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (optionSet == null)
{
return(nextOperation.Invoke());
}
System.Diagnostics.Debug.Assert(previousToken.Parent != null && currentToken.Parent != null);
var previousKind = previousToken.Kind();
var currentKind = currentToken.Kind();
var previousParentKind = previousToken.Parent.Kind();
var currentParentKind = currentToken.Parent.Kind();
// For Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// For Generic Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.GreaterThanToken && previousParentKind == SyntaxKind.TypeParameterList)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// Case: public static implicit operator string(Program p) { return null; }
if (previousToken.IsKeyword() && currentToken.IsOpenParenInParameterListOfAConversionOperatorDeclaration())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// Case: public static Program operator !(Program p) { return null; }
if (previousToken.Parent.IsKind(SyntaxKind.OperatorDeclaration) && currentToken.IsOpenParenInParameterListOfAOperationDeclaration())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses));
}
if (previousToken.IsOpenParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis));
}
if (currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis));
}
// For Method Call
if (currentToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName));
}
if (previousToken.IsOpenParenInArgumentList() && currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodCallParentheses));
}
if (previousToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
if (currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
// For spacing around: typeof, default, and sizeof; treat like a Method Call
if (currentKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName));
}
if (previousKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(previousParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
if (currentKind == SyntaxKind.CloseParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
// For Spacing b/n control flow keyword and paren. Parent check not needed.
if (currentKind == SyntaxKind.OpenParenToken &&
(previousKind == SyntaxKind.IfKeyword || previousKind == SyntaxKind.WhileKeyword || previousKind == SyntaxKind.SwitchKeyword ||
previousKind == SyntaxKind.ForKeyword || previousKind == SyntaxKind.ForEachKeyword || previousKind == SyntaxKind.CatchKeyword ||
previousKind == SyntaxKind.UsingKeyword))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterControlFlowStatementKeyword));
}
// For spacing between parenthesis and expression
if ((previousParentKind == SyntaxKind.ParenthesizedExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.ParenthesizedExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinExpressionParentheses));
}
// For spacing between the parenthesis and the cast expression
if ((previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.CastExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinCastParentheses));
}
// For spacing between the parenthesis and the expression inside the control flow expression
if (previousKind == SyntaxKind.OpenParenToken && IsControlFlowLikeKeywordStatementKind(previousParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses));
}
// Semicolons in an empty for statement. i.e. for(;;)
if (previousKind == SyntaxKind.OpenParenToken || previousKind == SyntaxKind.SemicolonToken)
{
if (previousToken.Parent.Kind() == SyntaxKind.ForStatement)
{
var forStatement = (ForStatementSyntax)previousToken.Parent;
if (forStatement.Initializers.Count == 0 &&
forStatement.Declaration == null &&
forStatement.Condition == null &&
forStatement.Incrementors.Count == 0)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
}
}
if (currentKind == SyntaxKind.CloseParenToken && IsControlFlowLikeKeywordStatementKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses));
}
// For spacing after the cast
if (previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterCast));
}
// For spacing Before Square Braces
if (currentKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(currentToken) && !previousToken.IsOpenBraceOrCommaOfObjectInitializer())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeOpenSquareBracket));
}
// For spacing empty square braces
if (previousKind == SyntaxKind.OpenBracketToken && (currentKind == SyntaxKind.CloseBracketToken || currentKind == SyntaxKind.OmittedArraySizeExpressionToken) && HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptySquareBrackets));
}
// For spacing square brackets within
if (previousKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets));
}
else if (currentKind == SyntaxKind.CloseBracketToken && HasFormattableBracketParent(currentToken))
{
if (currentToken.Parent is ArrayRankSpecifierSyntax)
{
var parent = currentToken.Parent as ArrayRankSpecifierSyntax;
if ((parent.Sizes.Any() && parent.Sizes.First().Kind() != SyntaxKind.OmittedArraySizeExpression) || parent.Sizes.SeparatorCount > 0)
{
// int []: added spacing operation on open [
// int[1], int[,]: need spacing operation
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets));
}
}
else
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets));
}
}
// For spacing delimiters - after colon
if (previousToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterColonInBaseTypeDeclaration));
}
// For spacing delimiters - before colon
if (currentToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeColonInBaseTypeDeclaration));
}
// For spacing delimiters - after comma
if ((previousToken.IsCommaInArgumentOrParameterList() && currentKind != SyntaxKind.OmittedTypeArgumentToken) ||
previousToken.IsCommaInInitializerExpression())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterComma));
}
// For spacing delimiters - before comma
if ((currentToken.IsCommaInArgumentOrParameterList() && previousKind != SyntaxKind.OmittedTypeArgumentToken) ||
currentToken.IsCommaInInitializerExpression())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeComma));
}
// For Spacing delimiters - after Dot
if (previousToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterDot));
}
// For spacing delimiters - before Dot
if (currentToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeDot));
}
// For spacing delimiters - after semicolon
if (previousToken.IsSemicolonInForStatement() && currentKind != SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement));
}
// For spacing delimiters - before semicolon
if (currentToken.IsSemicolonInForStatement())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement));
}
// For spacing around the binary operators
if (currentToken.Parent is BinaryExpressionSyntax ||
previousToken.Parent is BinaryExpressionSyntax ||
currentToken.Parent is AssignmentExpressionSyntax ||
previousToken.Parent is AssignmentExpressionSyntax)
{
switch (optionSet.GetOption(CSharpFormattingOptions.SpacingAroundBinaryOperator))
{
case BinaryOperatorSpacingOptions.Single:
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case BinaryOperatorSpacingOptions.Remove:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case BinaryOperatorSpacingOptions.Ignore:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
default:
System.Diagnostics.Debug.Assert(false, "Invalid BinaryOperatorSpacingOptions");
break;
}
}
// No space after $" and $@" at the start of an interpolated string
if (previousKind == SyntaxKind.InterpolatedStringStartToken ||
previousKind == SyntaxKind.InterpolatedVerbatimStringStartToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before " at the end of an interpolated string
if (currentKind == SyntaxKind.InterpolatedStringEndToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before { or after } in interpolations
if ((currentKind == SyntaxKind.OpenBraceToken && currentToken.Parent is InterpolationSyntax) ||
(previousKind == SyntaxKind.CloseBraceToken && previousToken.Parent is InterpolationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// Preserve space after { or before } in interpolations (i.e. between the braces and the expression)
if ((previousKind == SyntaxKind.OpenBraceToken && previousToken.Parent is InterpolationSyntax) ||
(currentKind == SyntaxKind.CloseBraceToken && currentToken.Parent is InterpolationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
}
// No space before or after , in interpolation alignment clause
if ((previousKind == SyntaxKind.CommaToken && previousToken.Parent is InterpolationAlignmentClauseSyntax) ||
(currentKind == SyntaxKind.CommaToken && currentToken.Parent is InterpolationAlignmentClauseSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before or after : in interpolation format clause
if ((previousKind == SyntaxKind.ColonToken && previousToken.Parent is InterpolationFormatClauseSyntax) ||
(currentKind == SyntaxKind.ColonToken && currentToken.Parent is InterpolationFormatClauseSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
//////////////////////////////////////////////////////
// ";" related operations
if (currentToken.Kind() == SyntaxKind.SemicolonToken)
{
// ; ;
if (previousToken.Kind() == SyntaxKind.SemicolonToken)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ) ; with embedded statement case
if (previousToken.Kind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * ;
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// omitted tokens case
if (previousToken.Kind() == SyntaxKind.OmittedArraySizeExpressionToken ||
previousToken.Kind() == SyntaxKind.OmittedTypeArgumentToken ||
currentToken.Kind() == SyntaxKind.OmittedArraySizeExpressionToken ||
currentToken.Kind() == SyntaxKind.OmittedTypeArgumentToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// extension method on tuple type
// M(this (
if (currentToken.Kind() == SyntaxKind.OpenParenToken &&
previousToken.Kind() == SyntaxKind.ThisKeyword)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// new (int, int)[]
if (currentToken.Kind() == SyntaxKind.OpenParenToken &&
previousToken.Kind() == SyntaxKind.NewKeyword &&
previousToken.Parent.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ArrayCreationExpression))
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// some * "(" cases
if (currentToken.Kind() == SyntaxKind.OpenParenToken)
{
if (previousToken.Kind() == SyntaxKind.IdentifierToken ||
previousToken.Kind() == SyntaxKind.DefaultKeyword ||
previousToken.Kind() == SyntaxKind.BaseKeyword ||
previousToken.Kind() == SyntaxKind.ThisKeyword ||
previousToken.Kind() == SyntaxKind.NewKeyword ||
previousToken.IsGenericGreaterThanToken() ||
currentToken.IsParenInArgumentList())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// empty () or []
if (previousToken.ParenOrBracketContainsNothing(currentToken))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// attribute case
// , [
if (previousToken.Kind() == SyntaxKind.CommaToken && currentToken.Kind() == SyntaxKind.OpenBracketToken && currentToken.Parent is AttributeListSyntax)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ] *
if (previousToken.Kind() == SyntaxKind.CloseBracketToken && previousToken.Parent is AttributeListSyntax)
{
// preserving dev10 behavior, in dev10 we didn't touch space after attribute
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
}
// * )
// * ]
// * ,
// * .
// * ->
switch (currentToken.Kind())
{
case SyntaxKind.CloseParenToken:
case SyntaxKind.CloseBracketToken:
case SyntaxKind.CommaToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * [
if (currentToken.IsKind(SyntaxKind.OpenBracketToken) &&
!previousToken.IsOpenBraceOrCommaOfObjectInitializer())
{
if (previousToken.IsOpenBraceOfAccessorList() ||
previousToken.IsLastTokenOfNode <AccessorDeclarationSyntax>())
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
else
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// case * :
// default:
// <label> :
if (currentToken.IsKind(SyntaxKind.ColonToken))
{
if (currentToken.Parent.IsKind(SyntaxKind.CaseSwitchLabel,
SyntaxKind.CasePatternSwitchLabel,
SyntaxKind.DefaultSwitchLabel,
SyntaxKind.LabeledStatement,
SyntaxKind.AttributeTargetSpecifier,
SyntaxKind.NameColon))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// [cast expression] * case
if (previousToken.Parent is CastExpressionSyntax &&
previousToken.Kind() == SyntaxKind.CloseParenToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// generic name
if (previousToken.Parent.Kind() == SyntaxKind.TypeArgumentList || previousToken.Parent.Kind() == SyntaxKind.TypeParameterList)
{
// generic name < *
if (previousToken.Kind() == SyntaxKind.LessThanToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// generic name > *
if (previousToken.Kind() == SyntaxKind.GreaterThanToken && currentToken.Kind() == SyntaxKind.GreaterThanToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// generic name * < or * >
if ((currentToken.Kind() == SyntaxKind.LessThanToken || currentToken.Kind() == SyntaxKind.GreaterThanToken) &&
(currentToken.Parent.Kind() == SyntaxKind.TypeArgumentList || currentToken.Parent.Kind() == SyntaxKind.TypeParameterList))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ++ * or -- *
if ((previousToken.Kind() == SyntaxKind.PlusPlusToken || previousToken.Kind() == SyntaxKind.MinusMinusToken) &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * ++ or * --
if ((currentToken.Kind() == SyntaxKind.PlusPlusToken || currentToken.Kind() == SyntaxKind.MinusMinusToken) &&
currentToken.Parent is PostfixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// For spacing between the identifier and the conditional operator
if (currentToken.IsKind(SyntaxKind.QuestionToken) && currentToken.Parent.Kind() == SyntaxKind.ConditionalAccessExpression)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// nullable
if (currentToken.Kind() == SyntaxKind.QuestionToken &&
currentToken.Parent.Kind() == SyntaxKind.NullableType)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// No space between an array type and ?
if (currentToken.IsKind(SyntaxKind.QuestionToken) &&
previousToken.Parent?.IsParentKind(SyntaxKind.ArrayType) == true)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// suppress warning operator: null! or x! or x++! or x[i]! or (x)! or ...
if (currentToken.Kind() == SyntaxKind.ExclamationToken &&
currentToken.Parent.Kind() == SyntaxKindEx.SuppressNullableWarningExpression)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ( * or ) * or [ * or ] * or . * or -> *
switch (previousToken.Kind())
{
case SyntaxKind.OpenParenToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case SyntaxKind.CloseParenToken:
case SyntaxKind.CloseBracketToken:
int space = (previousToken.Kind() == currentToken.Kind()) ? 0 : 1;
return(CreateAdjustSpacesOperation(space, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// +1 or -1
if (previousToken.IsPlusOrMinusExpression() && !currentToken.IsPlusOrMinusExpression())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// +- or -+
if (previousToken.IsPlusOrMinusExpression() && currentToken.IsPlusOrMinusExpression() &&
previousToken.Kind() != currentToken.Kind())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ! *, except where ! is the suppress nullable warning operator
if (previousToken.Kind() == SyntaxKind.ExclamationToken &&
previousToken.Parent.Kind() != SyntaxKindEx.SuppressNullableWarningExpression)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// pointer case
if ((currentToken.Kind() == SyntaxKind.AsteriskToken && currentToken.Parent is PointerTypeSyntax) ||
(previousToken.Kind() == SyntaxKind.AsteriskToken && previousToken.Parent is PrefixUnaryExpressionSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ~ * case
if (previousToken.Kind() == SyntaxKind.TildeToken && (previousToken.Parent is PrefixUnaryExpressionSyntax || previousToken.Parent is DestructorDeclarationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// & * case
if (previousToken.Kind() == SyntaxKind.AmpersandToken &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * :: or :: * case
if (previousToken.Kind() == SyntaxKind.ColonColonToken || currentToken.Kind() == SyntaxKind.ColonColonToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
if (optionSet == null)
{
return nextOperation.Invoke();
}
System.Diagnostics.Debug.Assert(previousToken.Parent != null && currentToken.Parent != null);
var previousKind = previousToken.Kind();
var currentKind = currentToken.Kind();
var previousParentKind = previousToken.Parent.Kind();
var currentParentKind = currentToken.Parent.Kind();
// For Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
}
// For Generic Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.GreaterThanToken && previousParentKind == SyntaxKind.TypeParameterList)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
}
// Case: public static implicit operator string(Program p) { return null; }
if (previousToken.IsKeyword() && currentToken.IsOpenParenInParameterListOfAConversionOperatorDeclaration())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
}
// Case: public static Program operator !(Program p) { return null; }
if (previousToken.Parent.IsKind(SyntaxKind.OperatorDeclaration) && currentToken.IsOpenParenInParameterListOfAOperationDeclaration())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
}
if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses);
}
if (previousToken.IsOpenParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis);
}
if (currentToken.IsCloseParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis);
}
// For Method Call
if (currentToken.IsOpenParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName);
}
if (previousToken.IsOpenParenInArgumentList() && currentToken.IsCloseParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodCallParentheses);
}
if (previousToken.IsOpenParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
if (currentToken.IsCloseParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
// For spacing around: typeof, default, and sizeof; treat like a Method Call
if (currentKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName);
}
if (previousKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(previousParentKind))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
if (currentKind == SyntaxKind.CloseParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
// For Spacing b/n control flow keyword and paren. Parent check not needed.
if (currentKind == SyntaxKind.OpenParenToken &&
(previousKind == SyntaxKind.IfKeyword || previousKind == SyntaxKind.WhileKeyword || previousKind == SyntaxKind.SwitchKeyword ||
previousKind == SyntaxKind.ForKeyword || previousKind == SyntaxKind.ForEachKeyword || previousKind == SyntaxKind.CatchKeyword ||
previousKind == SyntaxKind.UsingKeyword))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterControlFlowStatementKeyword);
}
// For spacing between parenthesis and expression
if ((previousParentKind == SyntaxKind.ParenthesizedExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.ParenthesizedExpression && currentKind == SyntaxKind.CloseParenToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinExpressionParentheses);
}
// For spacing between the parenthesis and the cast expression
if ((previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.CastExpression && currentKind == SyntaxKind.CloseParenToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinCastParentheses);
}
// For spacing between the parenthesis and the expression inside the control flow expression
if (previousKind == SyntaxKind.OpenParenToken && IsControlFlowLikeKeywordStatementKind(previousParentKind))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
}
// Semicolons in an empty for statement. i.e. for(;;)
if (previousKind == SyntaxKind.OpenParenToken || previousKind == SyntaxKind.SemicolonToken)
{
if (previousToken.Parent.Kind() == SyntaxKind.ForStatement)
{
var forStatement = (ForStatementSyntax)previousToken.Parent;
if (forStatement.Initializers.Count == 0 &&
forStatement.Declaration == null &&
forStatement.Condition == null &&
forStatement.Incrementors.Count == 0)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
}
}
if (currentKind == SyntaxKind.CloseParenToken && IsControlFlowLikeKeywordStatementKind(currentParentKind))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
}
// For spacing after the cast
if (previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.CloseParenToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterCast);
}
// For spacing Before Square Braces
if (currentKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(currentToken) && !previousToken.IsOpenBraceOrCommaOfObjectInitializer())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeOpenSquareBracket);
}
// For spacing empty square braces
if (previousKind == SyntaxKind.OpenBracketToken && (currentKind == SyntaxKind.CloseBracketToken || currentKind == SyntaxKind.OmittedArraySizeExpressionToken) && HasFormattableBracketParent(previousToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptySquareBrackets);
}
// For spacing square brackets within
if (previousKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(previousToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets);
}
else if (currentKind == SyntaxKind.CloseBracketToken && HasFormattableBracketParent(currentToken))
{
if (currentToken.Parent is ArrayRankSpecifierSyntax)
{
var parent = currentToken.Parent as ArrayRankSpecifierSyntax;
if ((parent.Sizes.Any() && parent.Sizes.First().Kind() != SyntaxKind.OmittedArraySizeExpression) || parent.Sizes.SeparatorCount > 0)
{
// int []: added spacing operation on open [
// int[1], int[,]: need spacing operation
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets);
}
}
else
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets);
}
}
// For spacing delimiters - after colon
if (previousToken.IsColonInTypeBaseList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterColonInBaseTypeDeclaration);
}
// For spacing delimiters - before colon
if (currentToken.IsColonInTypeBaseList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeColonInBaseTypeDeclaration);
}
// For spacing delimiters - after comma
if ((previousToken.IsCommaInArgumentOrParameterList() && currentKind != SyntaxKind.OmittedTypeArgumentToken) ||
previousToken.IsCommaInInitializerExpression())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterComma);
}
// For spacing delimiters - before comma
if ((currentToken.IsCommaInArgumentOrParameterList() && previousKind != SyntaxKind.OmittedTypeArgumentToken) ||
currentToken.IsCommaInInitializerExpression())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeComma);
}
// For Spacing delimiters - after Dot
if (previousToken.IsDotInMemberAccessOrQualifiedName())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterDot);
}
// For spacing delimiters - before Dot
if (currentToken.IsDotInMemberAccessOrQualifiedName())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeDot);
}
// For spacing delimiters - after semicolon
if (previousToken.IsSemicolonInForStatement() && currentKind != SyntaxKind.CloseParenToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement);
}
// For spacing delimiters - before semicolon
if (currentToken.IsSemicolonInForStatement())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement);
}
// For spacing around the binary operators
if (currentToken.Parent is BinaryExpressionSyntax ||
previousToken.Parent is BinaryExpressionSyntax ||
currentToken.Parent is AssignmentExpressionSyntax ||
previousToken.Parent is AssignmentExpressionSyntax)
{
switch (optionSet.GetOption(CSharpFormattingOptions.SpacingAroundBinaryOperator))
{
case BinaryOperatorSpacingOptions.Single:
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
case BinaryOperatorSpacingOptions.Remove:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
case BinaryOperatorSpacingOptions.Ignore:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces);
default:
System.Diagnostics.Debug.Assert(false, "Invalid BinaryOperatorSpacingOptions");
break;
}
}
// No space after $" and $@" at the start of an interpolated string
if (previousKind == SyntaxKind.InterpolatedStringStartToken ||
previousKind == SyntaxKind.InterpolatedVerbatimStringStartToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
// No space before " at the end of an interpolated string
if (currentKind == SyntaxKind.InterpolatedStringEndToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
// No space before { or after } in interpolations
if ((currentKind == SyntaxKind.OpenBraceToken && currentToken.Parent is InterpolationSyntax) ||
(previousKind == SyntaxKind.CloseBraceToken && previousToken.Parent is InterpolationSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
// Preserve space after { or before } in interpolations (i.e. between the braces and the expression)
if ((previousKind == SyntaxKind.OpenBraceToken && previousToken.Parent is InterpolationSyntax) ||
(currentKind == SyntaxKind.CloseBraceToken && currentToken.Parent is InterpolationSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces);
}
// No space before or after , in interpolation alignment clause
if ((previousKind == SyntaxKind.CommaToken && previousToken.Parent is InterpolationAlignmentClauseSyntax) ||
(currentKind == SyntaxKind.CommaToken && currentToken.Parent is InterpolationAlignmentClauseSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
// No space before or after : in interpolation format clause
if ((previousKind == SyntaxKind.ColonToken && previousToken.Parent is InterpolationFormatClauseSyntax) ||
(currentKind == SyntaxKind.ColonToken && currentToken.Parent is InterpolationFormatClauseSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
if (previousToken.IsNestedQueryExpression())
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
// skip the very first from keyword
if (currentToken.IsFirstFromKeywordInExpression())
{
return nextOperation.Invoke();
}
switch (currentToken.Kind())
{
case SyntaxKind.FromKeyword:
case SyntaxKind.WhereKeyword:
case SyntaxKind.LetKeyword:
case SyntaxKind.JoinKeyword:
case SyntaxKind.OrderByKeyword:
case SyntaxKind.GroupKeyword:
case SyntaxKind.SelectKeyword:
if (currentToken.GetAncestor<QueryExpressionSyntax>() != null)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForClausesInQuery))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
}
break;
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(
SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
if (IsQuestionOrColonOfNewConditional(currentToken))
{
// We want to force the ? and : to each be put onto the following line.
return(FormattingOperations.CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.ForceLines));
}
return(nextOperation.Invoke());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
// for extract method case, for a hybrid case, don't force rule, but preserve user style
var operation = base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
if (operation == null)
{
return(null);
}
if (operation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
{
return(FormattingOperations.CreateAdjustNewLinesOperation(operation.Line, AdjustNewLinesOption.PreserveLines));
}
if (operation.Option != AdjustNewLinesOption.ForceLines)
{
return(operation);
}
if (previousToken.RawKind == (int)SyntaxKind.OpenBraceToken)
{
return(operation);
}
if (previousToken.BetweenFieldAndNonFieldMember(currentToken))
{
// make sure to have at least 2 line breaks between field and other members except field
return(FormattingOperations.CreateAdjustNewLinesOperation(2, AdjustNewLinesOption.PreserveLines));
}
if (previousToken.HasHybridTriviaBetween(currentToken))
{
return(FormattingOperations.CreateAdjustNewLinesOperation(operation.Line, AdjustNewLinesOption.PreserveLines));
}
return(operation);
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
//////////////////////////////////////////////////////
// ";" related operations
if (currentToken.CSharpKind() == SyntaxKind.SemicolonToken)
{
// ; ;
if (previousToken.CSharpKind() == SyntaxKind.SemicolonToken)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ) ; with embedded statement case
if (previousToken.CSharpKind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * ;
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// omitted tokens case
if (previousToken.CSharpKind() == SyntaxKind.OmittedArraySizeExpressionToken ||
previousToken.CSharpKind() == SyntaxKind.OmittedTypeArgumentToken ||
currentToken.CSharpKind() == SyntaxKind.OmittedArraySizeExpressionToken ||
currentToken.CSharpKind() == SyntaxKind.OmittedTypeArgumentToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// some * "(" cases
if (currentToken.CSharpKind() == SyntaxKind.OpenParenToken)
{
if (previousToken.CSharpKind() == SyntaxKind.IdentifierToken ||
previousToken.CSharpKind() == SyntaxKind.DefaultKeyword ||
previousToken.CSharpKind() == SyntaxKind.BaseKeyword ||
previousToken.CSharpKind() == SyntaxKind.ThisKeyword ||
previousToken.CSharpKind() == SyntaxKind.NewKeyword ||
previousToken.Parent.CSharpKind() == SyntaxKind.OperatorDeclaration ||
previousToken.IsGenericGreaterThanToken() ||
currentToken.IsParenInArgumentList())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// empty () or []
if (previousToken.ParenOrBracketContainsNothing(currentToken))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// attribute case
// , [
if (previousToken.CSharpKind() == SyntaxKind.CommaToken && currentToken.CSharpKind() == SyntaxKind.OpenBracketToken && currentToken.Parent is AttributeListSyntax)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ] *
if (previousToken.CSharpKind() == SyntaxKind.CloseBracketToken && previousToken.Parent is AttributeListSyntax)
{
// preserving dev10 behavior, in dev10 we didn't touch space after attribute
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
}
// * )
// * [
// * ]
// * ,
// * .
// * ->
switch (currentToken.CSharpKind())
{
case SyntaxKind.CloseParenToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.CloseBracketToken:
case SyntaxKind.CommaToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// case * :
// default:
// <label> :
switch (currentToken.CSharpKind())
{
case SyntaxKind.ColonToken:
if (currentToken.IsParentKind(SyntaxKind.CaseSwitchLabel) ||
currentToken.IsParentKind(SyntaxKind.DefaultSwitchLabel) ||
currentToken.IsParentKind(SyntaxKind.LabeledStatement) ||
currentToken.IsParentKind(SyntaxKind.AttributeTargetSpecifier) ||
currentToken.IsParentKind(SyntaxKind.NameColon))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
break;
}
// [cast expression] * case
if (previousToken.Parent is CastExpressionSyntax &&
previousToken.CSharpKind() == SyntaxKind.CloseParenToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// generic name
if (previousToken.Parent.CSharpKind() == SyntaxKind.TypeArgumentList || previousToken.Parent.CSharpKind() == SyntaxKind.TypeParameterList)
{
// generic name < *
if (previousToken.CSharpKind() == SyntaxKind.LessThanToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// generic name > *
if (previousToken.CSharpKind() == SyntaxKind.GreaterThanToken && currentToken.CSharpKind() == SyntaxKind.GreaterThanToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// generic name * < or * >
if ((currentToken.CSharpKind() == SyntaxKind.LessThanToken || currentToken.CSharpKind() == SyntaxKind.GreaterThanToken) &&
(currentToken.Parent.CSharpKind() == SyntaxKind.TypeArgumentList || currentToken.Parent.CSharpKind() == SyntaxKind.TypeParameterList))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ++ * or -- *
if ((previousToken.CSharpKind() == SyntaxKind.PlusPlusToken || previousToken.CSharpKind() == SyntaxKind.MinusMinusToken) &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * ++ or * --
if ((currentToken.CSharpKind() == SyntaxKind.PlusPlusToken || currentToken.CSharpKind() == SyntaxKind.MinusMinusToken) &&
currentToken.Parent is PostfixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ( * or ) * or [ * or ] * or . * or -> *
switch (previousToken.CSharpKind())
{
case SyntaxKind.OpenParenToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case SyntaxKind.CloseParenToken:
case SyntaxKind.CloseBracketToken:
int space = (previousToken.CSharpKind() == currentToken.CSharpKind()) ? 0 : 1;
return(CreateAdjustSpacesOperation(space, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// +1 or -1
if (previousToken.IsPlusOrMinusExpression() && !currentToken.IsPlusOrMinusExpression())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// +- or -+
if (previousToken.IsPlusOrMinusExpression() && currentToken.IsPlusOrMinusExpression() &&
previousToken.CSharpKind() != currentToken.CSharpKind())
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ! *
if (previousToken.CSharpKind() == SyntaxKind.ExclamationToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// nullable
if (currentToken.CSharpKind() == SyntaxKind.QuestionToken &&
currentToken.Parent.CSharpKind() == SyntaxKind.NullableType)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// pointer case
if ((currentToken.CSharpKind() == SyntaxKind.AsteriskToken && currentToken.Parent is PointerTypeSyntax) ||
(previousToken.CSharpKind() == SyntaxKind.AsteriskToken && previousToken.Parent is PrefixUnaryExpressionSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// ~ * case
if (previousToken.CSharpKind() == SyntaxKind.TildeToken && (previousToken.Parent is PrefixUnaryExpressionSyntax || previousToken.Parent is DestructorDeclarationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// & * case
if (previousToken.CSharpKind() == SyntaxKind.AmpersandToken &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
// * :: or :: * case
if (previousToken.CSharpKind() == SyntaxKind.ColonColonToken || currentToken.CSharpKind() == SyntaxKind.ColonColonToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
return(nextOperation.Invoke());
}
public AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
return null;
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (optionSet == null)
{
return(nextOperation.Invoke());
}
System.Diagnostics.Debug.Assert(previousToken.Parent != null && currentToken.Parent != null);
var previousKind = previousToken.CSharpKind();
var currentKind = currentToken.CSharpKind();
var previousParentKind = previousToken.Parent.CSharpKind();
var currentParentKind = currentToken.Parent.CSharpKind();
// For Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodDeclarationNameParenthesis));
}
if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodDeclarationEmptyArgument));
}
if (previousToken.IsOpenParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodDeclarationParenthesisArgumentList));
}
if (currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodDeclarationParenthesisArgumentList));
}
// For Method Call
if (currentToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodCallNameParenthesis));
}
if (previousToken.IsOpenParenInArgumentList() && currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodCallEmptyArgument));
}
if (previousToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodCallArgumentList));
}
if (currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.MethodCallArgumentList));
}
// For Spacing b/n control flow keyword and paren. Parent check not needed.
if ((previousKind == SyntaxKind.IfKeyword || previousKind == SyntaxKind.WhileKeyword || previousKind == SyntaxKind.SwitchKeyword ||
previousKind == SyntaxKind.ForKeyword || previousKind == SyntaxKind.ForEachKeyword) &&
(currentKind == SyntaxKind.OpenParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherAfterControlFlowKeyword));
}
// For spacing between parenthesis and expression
if ((previousParentKind == SyntaxKind.ParenthesizedExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.ParenthesizedExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherBetweenParenthesisExpression));
}
// For spacing between the parenthesis and the cast expression
if ((previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.CastExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherParenthesisTypeCast));
}
// For spacing between the parenthesis and the expression inside the control flow expression
if ((previousParentKind == SyntaxKind.IfStatement || previousParentKind == SyntaxKind.WhileStatement || previousParentKind == SyntaxKind.SwitchStatement ||
previousParentKind == SyntaxKind.ForStatement || previousParentKind == SyntaxKind.ForEachStatement) &&
previousKind == SyntaxKind.OpenParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherParenControlFlow));
}
if ((currentParentKind == SyntaxKind.IfStatement || currentParentKind == SyntaxKind.WhileStatement || currentParentKind == SyntaxKind.SwitchStatement ||
currentParentKind == SyntaxKind.ForStatement || currentParentKind == SyntaxKind.ForEachStatement) &&
currentKind == SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherParenControlFlow));
}
// For spacing after the cast
if (previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.OtherParenAfterCast));
}
// For spacing Before Square Braces
if (currentKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(currentToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SquareBracesBefore));
}
// For spacing empty square braces
if (previousKind == SyntaxKind.OpenBracketToken && currentKind == SyntaxKind.OmittedArraySizeExpressionToken && HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SquareBracesEmpty));
}
// For spacing square brackets within
if (previousKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SquareBracesAndValue));
}
else if (currentKind == SyntaxKind.CloseBracketToken && HasFormattableBracketParent(currentToken))
{
if (currentToken.Parent is ArrayRankSpecifierSyntax)
{
var parent = currentToken.Parent as ArrayRankSpecifierSyntax;
if ((parent.Sizes.Any() && parent.Sizes.First().CSharpKind() != SyntaxKind.OmittedArraySizeExpression) || parent.Sizes.SeparatorCount > 0)
{
// int []: added spacing operation on open [
// int[1], int[,]: need spacing operation
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SquareBracesAndValue));
}
}
else
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SquareBracesAndValue));
}
}
// For spacing delimiters - after colon
if (previousToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersAfterColonInTypeDeclaration));
}
// For spacing delimiters - before colon
if (currentToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersBeforeColonInTypeDeclaration));
}
// For spacing delimiters - after comma
if ((previousToken.IsCommaInArgumentOrParameterList() && currentKind != SyntaxKind.OmittedTypeArgumentToken) ||
previousToken.IsCommaInInitializerExpression())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersAfterCommaInParameterArgument));
}
// For spacing delimiters - before comma
if ((currentToken.IsCommaInArgumentOrParameterList() && previousKind != SyntaxKind.OmittedTypeArgumentToken) ||
currentToken.IsCommaInInitializerExpression())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersBeforeCommaInParameterArgument));
}
// For Spacing delimiters - after Dot
if (previousToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersAfterDotMemberAccessQualifiedName));
}
// For spacing delimiters - before Dot
if (currentToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersBeforeDotMemberAccessQualifiedName));
}
// For spacing delimiters - after semicolon
if (previousToken.IsSemicolonInForStatement() && currentKind != SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersAfterSemiColonInForStatement));
}
// For spacing delimiters - before semicolon
if (currentToken.IsSemicolonInForStatement())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.DelimitersBeforeSemiColonInForStatement));
}
// For spacing around the binary operators
if (currentToken.Parent is BinaryExpressionSyntax || previousToken.Parent is BinaryExpressionSyntax)
{
switch (optionSet.GetOption(CSharpFormattingOptions.SpacingAroundBinaryOperator))
{
case BinaryOperatorSpacingOptions.Single:
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case BinaryOperatorSpacingOptions.Remove:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case BinaryOperatorSpacingOptions.Ignore:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
default:
System.Diagnostics.Debug.Assert(false, "Invalid BinaryOperatorSpacingOptions");
break;
}
}
return(nextOperation.Invoke());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
// Since we know the general shape of these new import statements, we simply look for where
// tokens are not on the same line and force them to only be separated by a single newline.
_text.GetLineAndOffset(previousToken.Span.Start, out int previousLine, out _);
_text.GetLineAndOffset(currentToken.Span.Start, out int currentLine, out _);
if (previousLine != currentLine)
{
return(FormattingOperations.CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.ForceLines));
}
return(null);
}
private AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (previousToken.CSharpKind() == SyntaxKind.HashToken && SyntaxFacts.IsPreprocessorKeyword(currentToken.CSharpKind()))
{
return(CreateAdjustSpacesOperation(space: 0, option: AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
if (previousToken.CSharpKind() == SyntaxKind.RegionKeyword && currentToken.CSharpKind() == SyntaxKind.EndOfDirectiveToken)
{
return(CreateAdjustSpacesOperation(space: 0, option: AdjustSpacesOption.PreserveSpaces));
}
if (currentToken.CSharpKind() == SyntaxKind.EndOfDirectiveToken)
{
return(CreateAdjustSpacesOperation(space: 0, option: AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
return(nextOperation.Invoke());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
if (operation == null)
{
// If there are more than one Type Parameter Constraint Clause then each go in separate line
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken) &&
currentToken.IsKind(SyntaxKind.WhereKeyword) &&
currentToken.Parent.IsKind(SyntaxKind.TypeParameterConstraintClause))
{
// Check if there is another TypeParameterConstraintClause before
if (previousToken.Parent.Ancestors().OfType <TypeParameterConstraintClauseSyntax>().Any())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// Check if there is another TypeParameterConstraintClause after
var firstTokenAfterTypeConstraint = currentToken.Parent.GetLastToken().GetNextToken();
var lastTokenForTypeConstraint = currentToken.Parent.GetLastToken().GetNextToken();
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(lastTokenForTypeConstraint, firstTokenAfterTypeConstraint) &&
firstTokenAfterTypeConstraint.IsKind(SyntaxKind.WhereKeyword) &&
firstTokenAfterTypeConstraint.Parent.IsKind(SyntaxKind.TypeParameterConstraintClause))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
}
return(null);
}
// if operation is already forced, return as it is.
if (operation.Option == AdjustNewLinesOption.ForceLines)
{
return(operation);
}
if (!CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken))
{
return(operation);
}
var betweenMemberOperation = GetAdjustNewLinesOperationBetweenMembers(previousToken, currentToken);
if (betweenMemberOperation != null)
{
return(betweenMemberOperation);
}
var line = Math.Max(LineBreaksAfter(previousToken, currentToken), operation.Line);
if (line == 0)
{
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
return(CreateAdjustNewLinesOperation(line, AdjustNewLinesOption.ForceLines));
}
/// <summary>
/// Wrap the large && expression after every && token.
/// </summary>
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(
SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
if (_syntaxFacts.IsLogicalAndExpression(previousToken.Parent))
{
return(FormattingOperations.CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
var spaceOperation = base.GetAdjustSpacesOperation(previousToken, currentToken, optionSet, nextOperation);
// if there is force space operation, convert it to ForceSpaceIfSingleLine operation.
// (force space basically means remove all line breaks)
if (spaceOperation != null && spaceOperation.Option == AdjustSpacesOption.ForceSpaces)
{
return FormattingOperations.CreateAdjustSpacesOperation(spaceOperation.Space, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
return spaceOperation;
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
// Eg Cases -
// new MyObject {
// new List<int> {
// int[] arr = {
// = new[] {
// = new int[] {
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null &&
(currentToken.Parent.Kind() == SyntaxKind.ObjectInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.CollectionInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.ArrayInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.ImplicitArrayCreationExpression))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
return base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
if (operation == null)
{
// If there are more than one Type Parameter Constraint Clause then each go in separate line
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken) &&
currentToken.IsKind(SyntaxKind.WhereKeyword) &&
currentToken.Parent.IsKind(SyntaxKind.TypeParameterConstraintClause))
{
// Check if there is another TypeParameterConstraintClause before
if (previousToken.Parent.Ancestors().OfType<TypeParameterConstraintClauseSyntax>().Any())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// Check if there is another TypeParameterConstraintClause after
var firstTokenAfterTypeConstraint = currentToken.Parent.GetLastToken().GetNextToken();
var lastTokenForTypeConstraint = currentToken.Parent.GetLastToken().GetNextToken();
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(lastTokenForTypeConstraint, firstTokenAfterTypeConstraint) &&
firstTokenAfterTypeConstraint.IsKind(SyntaxKind.WhereKeyword) &&
firstTokenAfterTypeConstraint.Parent.IsKind(SyntaxKind.TypeParameterConstraintClause))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
}
return null;
}
// if operation is already forced, return as it is.
if (operation.Option == AdjustNewLinesOption.ForceLines)
{
return operation;
}
if (!CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken))
{
return operation;
}
var betweenMemberOperation = GetAdjustNewLinesOperationBetweenMembers((SyntaxToken)previousToken, (SyntaxToken)currentToken);
if (betweenMemberOperation != null)
{
return betweenMemberOperation;
}
var line = Math.Max(LineBreaksAfter(previousToken, currentToken), operation.Line);
if (line == 0)
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
return CreateAdjustNewLinesOperation(line, AdjustNewLinesOption.ForceLines);
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
if (operation == null)
{
return(null);
}
// if operation is already forced, return as it is.
if (operation.Option == AdjustSpacesOption.ForceSpaces)
{
return(operation);
}
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken))
{
// current implementation of engine gives higher priority on new line operations over space operations if
// two are conflicting.
// ex) new line operation says add 1 line between tokens, and
// space operation says give 1 space between two tokens (basically means remove new lines)
// then, engine will pick new line operation and ignore space operation
// make attributes have a space following
if (previousToken.IsKind(SyntaxKind.CloseBracketToken) && previousToken.Parent is AttributeListSyntax &&
!(currentToken.Parent is AttributeListSyntax))
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces));
}
// make every operation forced
return(CreateAdjustSpacesOperation(Math.Max(0, operation.Space), AdjustSpacesOption.ForceSpaces));
}
return(operation);
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
if (operation == null)
{
return null;
}
// if operation is already forced, return as it is.
if (operation.Option == AdjustSpacesOption.ForceSpaces)
{
return operation;
}
if (CommonFormattingHelpers.HasAnyWhitespaceElasticTrivia(previousToken, currentToken))
{
// current implementation of engine gives higher priority on new line operations over space operations if
// two are conflicting.
// ex) new line operation says add 1 line between tokens, and
// space operation says give 1 space between two tokens (basically means remove new lines)
// then, engine will pick new line operation and ignore space operation
// make every operation forced
return CreateAdjustSpacesOperation(Math.Max(0, operation.Space), AdjustSpacesOption.ForceSpaces);
}
return operation;
}
public AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
////////////////////////////////////////////////////
// brace related operations
// * { or * }
switch (currentToken.Kind())
{
case SyntaxKind.OpenBraceToken:
if (currentToken.IsInterpolation())
{
return null;
}
if (!previousToken.IsParenInParenthesizedExpression())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
break;
case SyntaxKind.CloseBraceToken:
if (currentToken.IsInterpolation())
{
return null;
}
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// do { } while case
if (previousToken.Kind() == SyntaxKind.CloseBraceToken && currentToken.Kind() == SyntaxKind.WhileKeyword)
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
// { * or } *
switch (previousToken.Kind())
{
case SyntaxKind.CloseBraceToken:
if (previousToken.IsInterpolation())
{
return null;
}
if (!previousToken.IsCloseBraceOfExpression())
{
if (!currentToken.IsKind(SyntaxKind.SemicolonToken) &&
!currentToken.IsParenInParenthesizedExpression() &&
!currentToken.IsCommaInInitializerExpression() &&
!currentToken.IsCommaInAnyArgumentsList() &&
!currentToken.IsParenInArgumentList() &&
!currentToken.IsDotInMemberAccess() &&
!currentToken.IsCloseParenInStatement() &&
!currentToken.IsEqualsTokenInAutoPropertyInitializers())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
}
break;
case SyntaxKind.OpenBraceToken:
if (previousToken.IsInterpolation())
{
return null;
}
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
///////////////////////////////////////////////////
// statement related operations
// object and anonymous initializer "," case
if (previousToken.IsCommaInInitializerExpression())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// else * except else if case
if (previousToken.Kind() == SyntaxKind.ElseKeyword && currentToken.Kind() != SyntaxKind.IfKeyword)
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// , * in enum declarations
if (previousToken.IsCommaInEnumDeclaration())
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
// : cases
if (previousToken.IsColonInSwitchLabel() ||
previousToken.IsColonInLabeledStatement())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// embedded statement
if (previousToken.Kind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
if (previousToken.Kind() == SyntaxKind.DoKeyword && previousToken.Parent.Kind() == SyntaxKind.DoStatement)
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// for (int i = 10; i < 10; i++) case
if (previousToken.IsSemicolonInForStatement())
{
return nextOperation.Invoke();
}
// ; case in the switch case statement and else condition
if (previousToken.Kind() == SyntaxKind.SemicolonToken &&
(currentToken.Kind() == SyntaxKind.CaseKeyword || currentToken.Kind() == SyntaxKind.DefaultKeyword || currentToken.Kind() == SyntaxKind.ElseKeyword))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// ; * or ; * for using directive
if (previousToken.Kind() == SyntaxKind.SemicolonToken)
{
var line = (previousToken.Parent is UsingDirectiveSyntax) ? 1 : 0;
return CreateAdjustNewLinesOperation(line, AdjustNewLinesOption.PreserveLines);
}
// attribute case ] *
// force to next line for top level attributes
if (previousToken.Kind() == SyntaxKind.CloseBracketToken && previousToken.Parent is AttributeListSyntax)
{
var attributeOwner = (previousToken.Parent != null) ? previousToken.Parent.Parent : null;
if (attributeOwner is CompilationUnitSyntax ||
attributeOwner is MemberDeclarationSyntax ||
attributeOwner is AccessorDeclarationSyntax)
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
return nextOperation.Invoke();
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
////////////////////////////////////////////////////
// brace related operations
// * { or * }
switch (currentToken.Kind())
{
case SyntaxKind.OpenBraceToken:
if (currentToken.IsInterpolation())
{
return(null);
}
if (!previousToken.IsParenInParenthesizedExpression())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
break;
case SyntaxKind.CloseBraceToken:
if (currentToken.IsInterpolation())
{
return(null);
}
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// do { } while case
if (previousToken.Kind() == SyntaxKind.CloseBraceToken && currentToken.Kind() == SyntaxKind.WhileKeyword)
{
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
// { * or } *
switch (previousToken.Kind())
{
case SyntaxKind.CloseBraceToken:
if (previousToken.IsInterpolation())
{
return(null);
}
if (!previousToken.IsCloseBraceOfExpression())
{
if (!currentToken.IsKind(SyntaxKind.SemicolonToken) &&
!currentToken.IsParenInParenthesizedExpression() &&
!currentToken.IsCommaInInitializerExpression() &&
!currentToken.IsCommaInAnyArgumentsList() &&
!currentToken.IsParenInArgumentList() &&
!currentToken.IsDotInMemberAccess() &&
!currentToken.IsCloseParenInStatement() &&
!currentToken.IsEqualsTokenInAutoPropertyInitializers())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
}
break;
case SyntaxKind.OpenBraceToken:
if (previousToken.IsInterpolation())
{
return(null);
}
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
///////////////////////////////////////////////////
// statement related operations
// object and anonymous initializer "," case
if (previousToken.IsCommaInInitializerExpression())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// else * except else if case
if (previousToken.Kind() == SyntaxKind.ElseKeyword && currentToken.Kind() != SyntaxKind.IfKeyword)
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// , * in enum declarations
if (previousToken.IsCommaInEnumDeclaration())
{
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
// : cases
if (previousToken.IsColonInSwitchLabel() ||
previousToken.IsColonInLabeledStatement())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// embedded statement
if (previousToken.Kind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
if (previousToken.Kind() == SyntaxKind.DoKeyword && previousToken.Parent.Kind() == SyntaxKind.DoStatement)
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// for (int i = 10; i < 10; i++) case
if (previousToken.IsSemicolonInForStatement())
{
return(nextOperation.Invoke());
}
// ; case in the switch case statement and else condition
if (previousToken.Kind() == SyntaxKind.SemicolonToken &&
(currentToken.Kind() == SyntaxKind.CaseKeyword || currentToken.Kind() == SyntaxKind.DefaultKeyword || currentToken.Kind() == SyntaxKind.ElseKeyword))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
// ; * or ; * for using directive
if (previousToken.Kind() == SyntaxKind.SemicolonToken)
{
var line = (previousToken.Parent is UsingDirectiveSyntax) ? 1 : 0;
return(CreateAdjustNewLinesOperation(line, AdjustNewLinesOption.PreserveLines));
}
// attribute case ] *
// force to next line for top level attributes
if (previousToken.Kind() == SyntaxKind.CloseBracketToken && previousToken.Parent is AttributeListSyntax)
{
var attributeOwner = (previousToken.Parent != null) ? previousToken.Parent.Parent : null;
if (attributeOwner is CompilationUnitSyntax ||
attributeOwner is MemberDeclarationSyntax ||
attributeOwner is AccessorDeclarationSyntax)
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
return(nextOperation.Invoke());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
// else condition is actually handled in the GetAdjustSpacesOperation()
// For Object Initialization Expression
if (previousToken.Kind() == SyntaxKind.CommaToken && previousToken.Parent.Kind() == SyntaxKind.ObjectInitializerExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForMembersInObjectInit))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
// we never force it to move up unless it is already on same line
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
}
// For Anonymous Object Creation Expression
if (previousToken.Kind() == SyntaxKind.CommaToken && previousToken.Parent.Kind() == SyntaxKind.AnonymousObjectCreationExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForMembersInAnonymousTypes))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
// we never force it to move up unless it is already on same line
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
}
// } else in the if else context
if (previousToken.IsKind(SyntaxKind.CloseBraceToken) && currentToken.IsKind(SyntaxKind.ElseKeyword))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForElse))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// * catch in the try catch context
if (currentToken.Kind() == SyntaxKind.CatchKeyword)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForCatch))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// * Finally
if (currentToken.Kind() == SyntaxKind.FinallyKeyword)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForFinally))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// * { - in the type declaration context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInTypes))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// new { - Anonymous object creation
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentToken.Parent != null && currentToken.Parent.Kind() == SyntaxKind.AnonymousObjectCreationExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAnonymousTypes))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// new MyObject { - Object Initialization
// new List<int> { - Collection Initialization
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentToken.Parent != null &&
(currentToken.Parent.Kind() == SyntaxKind.ObjectInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.CollectionInitializerExpression))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// Array Initialization Expression
// int[] arr = new int[] {
// new[] {
// { - Implicit Array
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null &&
(currentToken.Parent.Kind() == SyntaxKind.ArrayInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.ImplicitArrayCreationExpression))
{
return(null);
}
var currentTokenParentParent = currentToken.Parent.Parent;
// * { - in the member declaration context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent is MemberDeclarationSyntax)
{
var option = currentTokenParentParent is BasePropertyDeclarationSyntax
? CSharpFormattingOptions.NewLinesForBracesInProperties
: CSharpFormattingOptions.NewLinesForBracesInMethods;
if (optionSet.GetOption(option))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// * { - in the property accessor context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent is AccessorDeclarationSyntax)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAccessors))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// * { - in the anonymous Method context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent.Kind() == SyntaxKind.AnonymousMethodExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAnonymousMethods))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.ForceLinesIfOnSingleLine));
}
else
{
return(null);
}
}
// * { - in the simple Lambda context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null &&
(currentTokenParentParent.Kind() == SyntaxKind.SimpleLambdaExpression || currentTokenParentParent.Kind() == SyntaxKind.ParenthesizedLambdaExpression))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInLambdaExpressionBody))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.ForceLinesIfOnSingleLine));
}
else
{
return(null);
}
}
// * { - in the control statement context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInControlBlocks))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
// Wrapping - Leave statements on same line (false):
// Insert a newline between the previous statement and this one.
// ; *
if (previousToken.Kind() == SyntaxKind.SemicolonToken &&
(previousToken.Parent is StatementSyntax && !previousToken.Parent.IsKind(SyntaxKind.ForStatement)) &&
!optionSet.GetOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
return(operation);
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
if (previousToken.Kind() == SyntaxKind.CommaToken && s_allowableKinds.Contains(previousToken.Parent.Kind()))
{
return(FormattingOperations.CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
return(base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation));
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
// else condition is actually handled in the GetAdjustSpacesOperation()
// For Object Initialization Expression
if (previousToken.CSharpKind() == SyntaxKind.CommaToken && previousToken.Parent.CSharpKind() == SyntaxKind.ObjectInitializerExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForMembersInObjectInit))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
// we never force it to move up unless it is already on same line
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
}
// For Anonymous Object Creation Expression
if (previousToken.CSharpKind() == SyntaxKind.CommaToken && previousToken.Parent.CSharpKind() == SyntaxKind.AnonymousObjectCreationExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForMembersInAnonymousTypes))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
// we never force it to move up unless it is already on same line
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
}
// } else in the if else context
if (previousToken.IsKind(SyntaxKind.CloseBraceToken) && currentToken.IsKind(SyntaxKind.ElseKeyword))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForElse))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// * catch in the try catch context
if (currentToken.CSharpKind() == SyntaxKind.CatchKeyword)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForCatch))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// * Finally
if (currentToken.CSharpKind() == SyntaxKind.FinallyKeyword)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForFinally))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// * { - in the type declaration context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForTypes))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// new { - Anonymous object creation
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && currentToken.Parent != null && currentToken.Parent.CSharpKind() == SyntaxKind.AnonymousObjectCreationExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForAnonymousType))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// new { - Object Initialization
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && currentToken.Parent != null && currentToken.Parent.CSharpKind() == SyntaxKind.ObjectInitializerExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForObjectInitializers))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
var currentTokenParentParent = currentToken.Parent.Parent;
// * { - in the member declaration context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken &&
currentTokenParentParent != null && (currentTokenParentParent is MemberDeclarationSyntax || currentTokenParentParent is AccessorDeclarationSyntax))
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForMethods))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// * { - in the anonymous Method context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null && currentTokenParentParent.CSharpKind() == SyntaxKind.AnonymousMethodExpression)
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForAnonymousMethods))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// * { - in the simple Lambda context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && currentTokenParentParent != null &&
(currentTokenParentParent.CSharpKind() == SyntaxKind.SimpleLambdaExpression || currentTokenParentParent.CSharpKind() == SyntaxKind.ParenthesizedLambdaExpression))
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForLambda))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.ForceIfSameLine);
}
else
{
return null;
}
}
// * { - in the control statement context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
{
if (optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForControl))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
else
{
return null;
}
}
// Wrapping - Leave statements on same line (false):
// Insert a newline between the previous statement and this one.
// ; *
if (previousToken.CSharpKind() == SyntaxKind.SemicolonToken
&& previousToken.Parent is StatementSyntax
&& !optionSet.GetOption(CSharpFormattingOptions.LeaveStatementMethodDeclarationSameLine))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
return operation;
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
// no line operation. no line changes what so ever
var lineOperation = base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation);
if (lineOperation != null)
{
// ignore force if same line option
if (lineOperation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
{
return(null);
}
// basically means don't ever put new line if there isn't already one, but do
// indentation.
return(FormattingOperations.CreateAdjustNewLinesOperation(line: 0, option: AdjustNewLinesOption.PreserveLines));
}
return(null);
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
if (previousToken.Parent is StructuredTriviaSyntax || currentToken.Parent is StructuredTriviaSyntax)
{
return(null);
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
//////////////////////////////////////////////////////
// ";" related operations
if (currentToken.Kind() == SyntaxKind.SemicolonToken)
{
// ; ;
if (previousToken.Kind() == SyntaxKind.SemicolonToken)
{
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ) ; with embedded statement case
if (previousToken.Kind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// * ;
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// omitted tokens case
if (previousToken.Kind() == SyntaxKind.OmittedArraySizeExpressionToken ||
previousToken.Kind() == SyntaxKind.OmittedTypeArgumentToken ||
currentToken.Kind() == SyntaxKind.OmittedArraySizeExpressionToken ||
currentToken.Kind() == SyntaxKind.OmittedTypeArgumentToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// some * "(" cases
if (currentToken.Kind() == SyntaxKind.OpenParenToken)
{
if (previousToken.Kind() == SyntaxKind.IdentifierToken ||
previousToken.Kind() == SyntaxKind.DefaultKeyword ||
previousToken.Kind() == SyntaxKind.BaseKeyword ||
previousToken.Kind() == SyntaxKind.ThisKeyword ||
previousToken.Kind() == SyntaxKind.NewKeyword ||
previousToken.IsGenericGreaterThanToken() ||
currentToken.IsParenInArgumentList())
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
}
// empty () or []
if (previousToken.ParenOrBracketContainsNothing(currentToken))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// attribute case
// , [
if (previousToken.Kind() == SyntaxKind.CommaToken && currentToken.Kind() == SyntaxKind.OpenBracketToken && currentToken.Parent is AttributeListSyntax)
{
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ] *
if (previousToken.Kind() == SyntaxKind.CloseBracketToken && previousToken.Parent is AttributeListSyntax)
{
// preserving dev10 behavior, in dev10 we didn't touch space after attribute
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces);
}
// * )
// * ]
// * ,
// * .
// * ->
switch (currentToken.Kind())
{
case SyntaxKind.CloseParenToken:
case SyntaxKind.CloseBracketToken:
case SyntaxKind.CommaToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// * [
if (currentToken.IsKind(SyntaxKind.OpenBracketToken) &&
!previousToken.IsOpenBraceOrCommaOfObjectInitializer())
{
if (previousToken.IsOpenBraceOfAccessorList() ||
previousToken.IsLastTokenOfNode<AccessorDeclarationSyntax>())
{
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
else
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
}
// case * :
// default:
// <label> :
if (currentToken.IsKind(SyntaxKind.ColonToken))
{
if (currentToken.Parent.IsKind(SyntaxKind.CaseSwitchLabel,
SyntaxKind.CasePatternSwitchLabel,
SyntaxKind.DefaultSwitchLabel,
SyntaxKind.LabeledStatement,
SyntaxKind.AttributeTargetSpecifier,
SyntaxKind.NameColon))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
}
// [cast expression] * case
if (previousToken.Parent is CastExpressionSyntax &&
previousToken.Kind() == SyntaxKind.CloseParenToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// generic name
if (previousToken.Parent.Kind() == SyntaxKind.TypeArgumentList || previousToken.Parent.Kind() == SyntaxKind.TypeParameterList)
{
// generic name < *
if (previousToken.Kind() == SyntaxKind.LessThanToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// generic name > *
if (previousToken.Kind() == SyntaxKind.GreaterThanToken && currentToken.Kind() == SyntaxKind.GreaterThanToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
}
// generic name * < or * >
if ((currentToken.Kind() == SyntaxKind.LessThanToken || currentToken.Kind() == SyntaxKind.GreaterThanToken) &&
(currentToken.Parent.Kind() == SyntaxKind.TypeArgumentList || currentToken.Parent.Kind() == SyntaxKind.TypeParameterList))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ++ * or -- *
if ((previousToken.Kind() == SyntaxKind.PlusPlusToken || previousToken.Kind() == SyntaxKind.MinusMinusToken) &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// * ++ or * --
if ((currentToken.Kind() == SyntaxKind.PlusPlusToken || currentToken.Kind() == SyntaxKind.MinusMinusToken) &&
currentToken.Parent is PostfixUnaryExpressionSyntax)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// For spacing between the identifier and the conditional operator
if (currentToken.IsKind(SyntaxKind.QuestionToken) && currentToken.Parent.Kind() == SyntaxKind.ConditionalAccessExpression)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ( * or ) * or [ * or ] * or . * or -> *
switch (previousToken.Kind())
{
case SyntaxKind.OpenParenToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.DotToken:
case SyntaxKind.MinusGreaterThanToken:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
case SyntaxKind.CloseParenToken:
case SyntaxKind.CloseBracketToken:
int space = (previousToken.Kind() == currentToken.Kind()) ? 0 : 1;
return CreateAdjustSpacesOperation(space, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// +1 or -1
if (previousToken.IsPlusOrMinusExpression() && !currentToken.IsPlusOrMinusExpression())
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// +- or -+
if (previousToken.IsPlusOrMinusExpression() && currentToken.IsPlusOrMinusExpression() &&
previousToken.Kind() != currentToken.Kind())
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ! *
if (previousToken.Kind() == SyntaxKind.ExclamationToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// nullable
if (currentToken.Kind() == SyntaxKind.QuestionToken &&
currentToken.Parent.Kind() == SyntaxKind.NullableType)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// pointer case
if ((currentToken.Kind() == SyntaxKind.AsteriskToken && currentToken.Parent is PointerTypeSyntax) ||
(previousToken.Kind() == SyntaxKind.AsteriskToken && previousToken.Parent is PrefixUnaryExpressionSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// ~ * case
if (previousToken.Kind() == SyntaxKind.TildeToken && (previousToken.Parent is PrefixUnaryExpressionSyntax || previousToken.Parent is DestructorDeclarationSyntax))
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// & * case
if (previousToken.Kind() == SyntaxKind.AmpersandToken &&
previousToken.Parent is PrefixUnaryExpressionSyntax)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
// * :: or :: * case
if (previousToken.Kind() == SyntaxKind.ColonColonToken || currentToken.Kind() == SyntaxKind.ColonColonToken)
{
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
}
return nextOperation.Invoke();
}
// return 1 space for every token pairs as a default operation
public AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
int space = currentToken.Kind() == SyntaxKind.EndOfFileToken ? 0 : 1;
return FormattingOperations.CreateAdjustSpacesOperation(space, AdjustSpacesOption.DefaultSpacesIfOnSingleLine);
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
// Eg Cases -
// new MyObject {
// new List<int> {
// int[] arr = {
// = new[] {
// = new int[] {
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null &&
(currentToken.Parent.Kind() == SyntaxKind.ObjectInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.CollectionInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.ArrayInitializerExpression ||
currentToken.Parent.Kind() == SyntaxKind.ImplicitArrayCreationExpression))
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(null);
}
}
return(base.GetAdjustNewLinesOperation(previousToken, currentToken, optionSet, nextOperation));
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (optionSet == null)
{
return(nextOperation.Invoke());
}
System.Diagnostics.Debug.Assert(previousToken.Parent != null && currentToken.Parent != null);
var previousKind = previousToken.Kind();
var currentKind = currentToken.Kind();
var previousParentKind = previousToken.Parent.Kind();
var currentParentKind = currentToken.Parent.Kind();
// For Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// For Generic Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.GreaterThanToken && previousParentKind == SyntaxKind.TypeParameterList)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// Case: public static implicit operator string(Program p) { return null; }
if (previousToken.IsKeyword() && currentToken.IsOpenParenInParameterListOfAConversionOperatorDeclaration())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
// Case: public static Program operator !(Program p) { return null; }
if (previousToken.Parent.IsKind(SyntaxKind.OperatorDeclaration) && currentToken.IsOpenParenInParameterListOfAOperationDeclaration())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName));
}
if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses));
}
if (previousToken.IsOpenParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis));
}
if (currentToken.IsCloseParenInParameterList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis));
}
// For Method Call
if (currentToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName));
}
if (previousToken.IsOpenParenInArgumentList() && currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodCallParentheses));
}
if (previousToken.IsOpenParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
if (currentToken.IsCloseParenInArgumentList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
// For spacing around: typeof, default, and sizeof; treat like a Method Call
if (currentKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName));
}
if (previousKind == SyntaxKind.OpenParenToken && IsFunctionLikeKeywordExpressionKind(previousParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
if (currentKind == SyntaxKind.CloseParenToken && IsFunctionLikeKeywordExpressionKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses));
}
// For Spacing b/n control flow keyword and paren. Parent check not needed.
if (currentKind == SyntaxKind.OpenParenToken &&
(previousKind == SyntaxKind.IfKeyword || previousKind == SyntaxKind.WhileKeyword || previousKind == SyntaxKind.SwitchKeyword ||
previousKind == SyntaxKind.ForKeyword || previousKind == SyntaxKind.ForEachKeyword || previousKind == SyntaxKind.CatchKeyword ||
previousKind == SyntaxKind.UsingKeyword || previousKind == SyntaxKind.WhenKeyword || previousKind == SyntaxKind.LockKeyword))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterControlFlowStatementKeyword));
}
// For spacing between parenthesis and expression
if ((previousParentKind == SyntaxKind.ParenthesizedExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.ParenthesizedExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinExpressionParentheses));
}
// For spacing between the parenthesis and the cast expression
if ((previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.CastExpression && currentKind == SyntaxKind.CloseParenToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinCastParentheses));
}
// Semicolons in an empty for statement. i.e. for(;;)
if (previousParentKind == SyntaxKind.ForStatement &&
this.IsEmptyForStatement((ForStatementSyntax)previousToken.Parent))
{
if (currentKind == SyntaxKind.SemicolonToken &&
(previousKind != SyntaxKind.SemicolonToken ||
optionSet.GetOption <bool>(CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement)))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement));
}
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement));
}
// For spacing between the parenthesis and the expression inside the control flow expression
if (previousKind == SyntaxKind.OpenParenToken && IsControlFlowLikeKeywordStatementKind(previousParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses));
}
if (currentKind == SyntaxKind.CloseParenToken && IsControlFlowLikeKeywordStatementKind(currentParentKind))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses));
}
// For spacing after the cast
if (previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterCast));
}
// For spacing Before Square Braces
if (currentKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(currentToken) && !previousToken.IsOpenBraceOrCommaOfObjectInitializer())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeOpenSquareBracket));
}
// For spacing empty square braces, also treat [,] as empty
if (((currentKind == SyntaxKind.CloseBracketToken && previousKind == SyntaxKind.OpenBracketToken) ||
currentKind == SyntaxKind.OmittedArraySizeExpressionToken) &&
HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptySquareBrackets));
}
// For spacing square brackets within
if (previousKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(previousToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets));
}
if (currentKind == SyntaxKind.CloseBracketToken && previousKind != SyntaxKind.OmittedArraySizeExpressionToken && HasFormattableBracketParent(currentToken))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquareBrackets));
}
// attribute case ] *
// Place a space between the attribute and the next member if they're on the same line.
if (previousKind == SyntaxKind.CloseBracketToken && previousToken.Parent.IsKind(SyntaxKind.AttributeList))
{
var attributeOwner = previousToken.Parent?.Parent;
if (attributeOwner is MemberDeclarationSyntax)
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
}
// For spacing delimiters - after colon
if (previousToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterColonInBaseTypeDeclaration));
}
// For spacing delimiters - before colon
if (currentToken.IsColonInTypeBaseList())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeColonInBaseTypeDeclaration));
}
// For spacing delimiters - after comma
if ((previousToken.IsCommaInArgumentOrParameterList() && currentKind != SyntaxKind.OmittedTypeArgumentToken) ||
previousToken.IsCommaInInitializerExpression() ||
(previousKind == SyntaxKind.CommaToken &&
currentKind != SyntaxKind.OmittedArraySizeExpressionToken &&
HasFormattableBracketParent(previousToken)))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterComma));
}
// For spacing delimiters - before comma
if ((currentToken.IsCommaInArgumentOrParameterList() && previousKind != SyntaxKind.OmittedTypeArgumentToken) ||
currentToken.IsCommaInInitializerExpression() ||
(currentKind == SyntaxKind.CommaToken &&
previousKind != SyntaxKind.OmittedArraySizeExpressionToken &&
HasFormattableBracketParent(currentToken)))
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeComma));
}
// For Spacing delimiters - after Dot
if (previousToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterDot));
}
// For spacing delimiters - before Dot
if (currentToken.IsDotInMemberAccessOrQualifiedName())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeDot));
}
// For spacing delimiters - after semicolon
if (previousToken.IsSemicolonInForStatement() && currentKind != SyntaxKind.CloseParenToken)
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement));
}
// For spacing delimiters - before semicolon
if (currentToken.IsSemicolonInForStatement())
{
return(AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement));
}
// For spacing around the binary operators
if (currentToken.Parent is BinaryExpressionSyntax ||
previousToken.Parent is BinaryExpressionSyntax ||
currentToken.Parent is AssignmentExpressionSyntax ||
previousToken.Parent is AssignmentExpressionSyntax)
{
switch (optionSet.GetOption(CSharpFormattingOptions.SpacingAroundBinaryOperator))
{
case BinaryOperatorSpacingOptions.Single:
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
case BinaryOperatorSpacingOptions.Remove:
if (currentKind == SyntaxKind.IsKeyword ||
currentKind == SyntaxKind.AsKeyword ||
previousKind == SyntaxKind.IsKeyword ||
previousKind == SyntaxKind.AsKeyword)
{
// User want spaces removed but at least one is required for the "as" & "is" keyword
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
else
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine));
}
case BinaryOperatorSpacingOptions.Ignore:
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
default:
System.Diagnostics.Debug.Assert(false, "Invalid BinaryOperatorSpacingOptions");
break;
}
}
// No space after $" and $@" and @$" at the start of an interpolated string
if (previousKind == SyntaxKind.InterpolatedStringStartToken ||
previousKind == SyntaxKind.InterpolatedVerbatimStringStartToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before " at the end of an interpolated string
if (currentKind == SyntaxKind.InterpolatedStringEndToken)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before { or after } in interpolations
if ((currentKind == SyntaxKind.OpenBraceToken && currentToken.Parent is InterpolationSyntax) ||
(previousKind == SyntaxKind.CloseBraceToken && previousToken.Parent is InterpolationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// Preserve space after { or before } in interpolations (i.e. between the braces and the expression)
if ((previousKind == SyntaxKind.OpenBraceToken && previousToken.Parent is InterpolationSyntax) ||
(currentKind == SyntaxKind.CloseBraceToken && currentToken.Parent is InterpolationSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces));
}
// No space before or after , in interpolation alignment clause
if ((previousKind == SyntaxKind.CommaToken && previousToken.Parent is InterpolationAlignmentClauseSyntax) ||
(currentKind == SyntaxKind.CommaToken && currentToken.Parent is InterpolationAlignmentClauseSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// No space before or after : in interpolation format clause
if ((previousKind == SyntaxKind.ColonToken && previousToken.Parent is InterpolationFormatClauseSyntax) ||
(currentKind == SyntaxKind.ColonToken && currentToken.Parent is InterpolationFormatClauseSyntax))
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// Always put a space in the var form of deconstruction-declaration
if (currentToken.IsOpenParenInVarDeconstructionDeclaration())
{
return(CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces));
}
// Index expressions
if (previousKind == SyntaxKind.CaretToken && previousParentKind == SyntaxKindEx.IndexExpression)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
// Right of Range expressions
if (previousKind == SyntaxKindEx.DotDotToken && previousParentKind == SyntaxKindEx.RangeExpression)
{
#if !CODE_STYLE
var rangeExpression = (RangeExpressionSyntax)previousToken.Parent;
var hasRightOperand = rangeExpression.RightOperand != null;
#else
var childSyntax = previousToken.Parent.ChildNodesAndTokens();
var hasRightOperand = childSyntax.Count > 1 && childSyntax[childSyntax.Count - 2].IsKind(SyntaxKindEx.DotDotToken);
#endif
if (hasRightOperand)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
}
// Left of Range expressions
if (currentKind == SyntaxKindEx.DotDotToken && currentParentKind == SyntaxKindEx.RangeExpression)
{
#if !CODE_STYLE
var rangeExpression = (RangeExpressionSyntax)currentToken.Parent;
var hasLeftOperand = rangeExpression.LeftOperand != null;
#else
var childSyntax = currentToken.Parent.ChildNodesAndTokens();
var hasLeftOperand = childSyntax.Count > 1 && childSyntax[1].IsKind(SyntaxKindEx.DotDotToken);
#endif
if (hasLeftOperand)
{
return(CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces));
}
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
// } else in the if else context
if (previousToken.IsKind(SyntaxKind.CloseBraceToken) && currentToken.IsKind(SyntaxKind.ElseKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForElse))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * catch in the try catch context
if (currentToken.IsKind(SyntaxKind.CatchKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForCatch))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * finally
if (currentToken.IsKind(SyntaxKind.FinallyKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForFinally))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { in the type declaration context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInTypes))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// new { - Anonymous object creation
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null && currentToken.Parent.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAnonymousTypes))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// new { - Object Initialization
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null && currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
var currentTokenParentParent = currentToken.Parent.Parent;
// * { - in the member declaration context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent is MemberDeclarationSyntax)
{
var option = currentTokenParentParent is BasePropertyDeclarationSyntax
? CSharpFormattingOptions.NewLinesForBracesInProperties
: CSharpFormattingOptions.NewLinesForBracesInMethods;
if (!optionSet.GetOption(option))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent is AccessorDeclarationSyntax)
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAccessors))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the anonymous Method context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent.IsKind(SyntaxKind.AnonymousMethodExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInAnonymousMethods))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the Lambda context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null &&
(currentTokenParentParent.IsKind(SyntaxKind.SimpleLambdaExpression) || currentTokenParentParent.IsKind(SyntaxKind.ParenthesizedLambdaExpression)))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInLambdaExpressionBody))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the control statement context
if (currentToken.Kind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLinesForBracesInControlBlocks))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
return(operation);
}
public AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
return(null);
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
var operation = nextOperation.Invoke();
// } else in the if else context
if (previousToken.IsKind(SyntaxKind.CloseBraceToken) && currentToken.IsKind(SyntaxKind.ElseKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForElse))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * catch in the try catch context
if (currentToken.IsKind(SyntaxKind.CatchKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForCatch))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * finally
if (currentToken.IsKind(SyntaxKind.FinallyKeyword))
{
if (!optionSet.GetOption(CSharpFormattingOptions.NewLineForFinally))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { in the type declaration context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && (currentToken.Parent is BaseTypeDeclarationSyntax || currentToken.Parent is NamespaceDeclarationSyntax))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForTypes))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// new { - Anonymous object creation
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null && currentToken.Parent.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForAnonymousType))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// new { - Object Initialization
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentToken.Parent != null && currentToken.Parent.IsKind(SyntaxKind.ObjectInitializerExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForObjectInitializers))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
var currentTokenParentParent = currentToken.Parent.Parent;
// * { - in the member declaration context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null &&
(currentTokenParentParent is MemberDeclarationSyntax || currentTokenParentParent is AccessorDeclarationSyntax))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForMethods))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the anonymous Method context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null && currentTokenParentParent.IsKind(SyntaxKind.AnonymousMethodExpression))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForAnonymousMethods))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the Lambda context
if (currentToken.IsKind(SyntaxKind.OpenBraceToken) && currentTokenParentParent != null &&
(currentTokenParentParent.IsKind(SyntaxKind.SimpleLambdaExpression) || currentTokenParentParent.IsKind(SyntaxKind.ParenthesizedLambdaExpression)))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForLambda))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
// * { - in the control statement context
if (currentToken.CSharpKind() == SyntaxKind.OpenBraceToken && IsControlBlock(currentToken.Parent))
{
if (!optionSet.GetOption(CSharpFormattingOptions.OpenBracesInNewLineForControl))
{
operation = CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces);
}
}
return operation;
}
// return 1 space for every token pairs as a default operation
public AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
int space = currentToken.Kind() == SyntaxKind.EndOfFileToken ? 0 : 1;
return(FormattingOperations.CreateAdjustSpacesOperation(space, AdjustSpacesOption.DefaultSpacesIfOnSingleLine));
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (previousToken.Parent is StructuredTriviaSyntax || currentToken.Parent is StructuredTriviaSyntax)
{
// this doesn't take care of all cases where tokens belong to structured trivia. this is only for cases we care
return(GetAdjustSpacesOperation(previousToken, currentToken, nextOperation));
}
return(nextOperation.Invoke());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustNewLinesOperation> nextOperation)
{
if (previousToken.IsNestedQueryExpression())
{
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
// skip the very first from keyword
if (currentToken.IsFirstFromKeywordInExpression())
{
return(nextOperation.Invoke());
}
switch (currentToken.Kind())
{
case SyntaxKind.FromKeyword:
case SyntaxKind.WhereKeyword:
case SyntaxKind.LetKeyword:
case SyntaxKind.JoinKeyword:
case SyntaxKind.OrderByKeyword:
case SyntaxKind.GroupKeyword:
case SyntaxKind.SelectKeyword:
if (currentToken.GetAncestor <QueryExpressionSyntax>() != null)
{
if (optionSet.GetOption(CSharpFormattingOptions.NewLineForClausesInQuery))
{
return(CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines));
}
else
{
return(CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines));
}
}
break;
}
return(nextOperation.Invoke());
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation <AdjustSpacesOperation> nextOperation)
{
if (ForceSingleSpace(previousToken, currentToken))
{
return(new AdjustSpacesOperation(1, AdjustSpacesOption.ForceSpaces));
}
return(base.GetAdjustSpacesOperation(previousToken, currentToken, optionSet, nextOperation));
}
public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)
{
if (optionSet == null)
{
return nextOperation.Invoke();
}
System.Diagnostics.Debug.Assert(previousToken.Parent != null && currentToken.Parent != null);
var previousKind = previousToken.CSharpKind();
var currentKind = currentToken.CSharpKind();
var previousParentKind = previousToken.Parent.CSharpKind();
var currentParentKind = currentToken.Parent.CSharpKind();
// For Method Declaration
if (currentToken.IsOpenParenInParameterList() && previousKind == SyntaxKind.IdentifierToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
}
if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses);
}
if (previousToken.IsOpenParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis);
}
if (currentToken.IsCloseParenInParameterList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodDeclarationParenthesis);
}
// For Method Call
if (currentToken.IsOpenParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterMethodCallName);
}
if (previousToken.IsOpenParenInArgumentList() && currentToken.IsCloseParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodCallParentheses);
}
if (previousToken.IsOpenParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
if (currentToken.IsCloseParenInArgumentList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinMethodCallParentheses);
}
// For Spacing b/n control flow keyword and paren. Parent check not needed.
if (currentKind == SyntaxKind.OpenParenToken &&
(previousKind == SyntaxKind.IfKeyword || previousKind == SyntaxKind.WhileKeyword || previousKind == SyntaxKind.SwitchKeyword ||
previousKind == SyntaxKind.ForKeyword || previousKind == SyntaxKind.ForEachKeyword))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterControlFlowStatementKeyword);
}
// For spacing between parenthesis and expression
if ((previousParentKind == SyntaxKind.ParenthesizedExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.ParenthesizedExpression && currentKind == SyntaxKind.CloseParenToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinExpressionParentheses);
}
// For spacing between the parenthesis and the cast expression
if ((previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.OpenParenToken) ||
(currentParentKind == SyntaxKind.CastExpression && currentKind == SyntaxKind.CloseParenToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinCastParentheses);
}
// For spacing between the parenthesis and the expression inside the control flow expression
if (previousKind == SyntaxKind.OpenParenToken &&
(previousParentKind == SyntaxKind.IfStatement || previousParentKind == SyntaxKind.WhileStatement || previousParentKind == SyntaxKind.SwitchStatement ||
previousParentKind == SyntaxKind.ForStatement || previousParentKind == SyntaxKind.ForEachStatement || previousParentKind == SyntaxKind.DoStatement ||
previousParentKind == SyntaxKind.CatchDeclaration))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
}
if (currentKind == SyntaxKind.CloseParenToken &&
(currentParentKind == SyntaxKind.IfStatement || currentParentKind == SyntaxKind.WhileStatement || currentParentKind == SyntaxKind.SwitchStatement ||
currentParentKind == SyntaxKind.ForStatement || currentParentKind == SyntaxKind.ForEachStatement || currentParentKind == SyntaxKind.DoStatement ||
previousParentKind == SyntaxKind.CatchDeclaration))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
}
// For spacing after the cast
if (previousParentKind == SyntaxKind.CastExpression && previousKind == SyntaxKind.CloseParenToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterCast);
}
// For spacing Before Square Braces
if (currentKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(currentToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeOpenSquare);
}
// For spacing empty square braces
if (previousKind == SyntaxKind.OpenBracketToken && currentKind == SyntaxKind.OmittedArraySizeExpressionToken && HasFormattableBracketParent(previousToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptySquares);
}
// For spacing square brackets within
if (previousKind == SyntaxKind.OpenBracketToken && HasFormattableBracketParent(previousToken))
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquares);
}
else if (currentKind == SyntaxKind.CloseBracketToken && HasFormattableBracketParent(currentToken))
{
if (currentToken.Parent is ArrayRankSpecifierSyntax)
{
var parent = currentToken.Parent as ArrayRankSpecifierSyntax;
if ((parent.Sizes.Any() && parent.Sizes.First().CSharpKind() != SyntaxKind.OmittedArraySizeExpression) || parent.Sizes.SeparatorCount > 0)
{
// int []: added spacing operation on open [
// int[1], int[,]: need spacing operation
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquares);
}
}
else
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinSquares);
}
}
// For spacing delimiters - after colon
if (previousToken.IsColonInTypeBaseList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterColonInBaseTypeDeclaration);
}
// For spacing delimiters - before colon
if (currentToken.IsColonInTypeBaseList())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeColonInBaseTypeDeclaration);
}
// For spacing delimiters - after comma
if ((previousToken.IsCommaInArgumentOrParameterList() && currentKind != SyntaxKind.OmittedTypeArgumentToken) ||
previousToken.IsCommaInInitializerExpression())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterComma);
}
// For spacing delimiters - before comma
if ((currentToken.IsCommaInArgumentOrParameterList() && previousKind != SyntaxKind.OmittedTypeArgumentToken) ||
currentToken.IsCommaInInitializerExpression())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeComma);
}
// For Spacing delimiters - after Dot
if (previousToken.IsDotInMemberAccessOrQualifiedName())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterDot);
}
// For spacing delimiters - before Dot
if (currentToken.IsDotInMemberAccessOrQualifiedName())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeDot);
}
// For spacing delimiters - after semicolon
if (previousToken.IsSemicolonInForStatement() && currentKind != SyntaxKind.CloseParenToken)
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement);
}
// For spacing delimiters - before semicolon
if (currentToken.IsSemicolonInForStatement())
{
return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement);
}
// For spacing around the binary operators
if (currentToken.Parent is BinaryExpressionSyntax || previousToken.Parent is BinaryExpressionSyntax)
{
switch (optionSet.GetOption(CSharpFormattingOptions.SpacingAroundBinaryOperator))
{
case BinaryOperatorSpacingOptions.Single:
return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
case BinaryOperatorSpacingOptions.Remove:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
case BinaryOperatorSpacingOptions.Ignore:
return CreateAdjustSpacesOperation(0, AdjustSpacesOption.PreserveSpaces);
default:
System.Diagnostics.Debug.Assert(false, "Invalid BinaryOperatorSpacingOptions");
break;
}
}
return nextOperation.Invoke();
}
