private void ClassifyXmlTextToken(SyntaxToken token)
{
if (token.CSharpKind() == SyntaxKind.XmlEntityLiteralToken)
{
AddClassification(token, ClassificationTypeNames.XmlDocCommentEntityReference);
}
else if (token.CSharpKind() != SyntaxKind.XmlTextLiteralNewLineToken)
{
switch (token.Parent.CSharpKind())
{
case SyntaxKind.XmlText:
AddClassification(token, ClassificationTypeNames.XmlDocCommentText);
break;
case SyntaxKind.XmlTextAttribute:
AddClassification(token, ClassificationTypeNames.XmlDocCommentAttributeValue);
break;
case SyntaxKind.XmlComment:
AddClassification(token, ClassificationTypeNames.XmlDocCommentComment);
break;
case SyntaxKind.XmlCDataSection:
AddClassification(token, ClassificationTypeNames.XmlDocCommentCDataSection);
break;
case SyntaxKind.XmlProcessingInstruction:
AddClassification(token, ClassificationTypeNames.XmlDocCommentProcessingInstruction);
break;
}
}
}
public static bool IsTypeParameterVarianceContext(this SyntaxToken targetToken)
{
// cases:
// interface IFoo<|
// interface IFoo<A,|
// interface IFoo<[Bar]|
// deletate X D<|
// deletate X D<A,|
// deletate X D<[Bar]|
if (targetToken.CSharpKind() == SyntaxKind.LessThanToken &&
IsGenericInterfaceOrDelegateTypeParameterList(targetToken.Parent))
{
return(true);
}
if (targetToken.CSharpKind() == SyntaxKind.CommaToken &&
IsGenericInterfaceOrDelegateTypeParameterList(targetToken.Parent))
{
return(true);
}
if (targetToken.CSharpKind() == SyntaxKind.CloseBracketToken &&
targetToken.Parent.IsKind(SyntaxKind.AttributeList) &&
targetToken.Parent.IsParentKind(SyntaxKind.TypeParameter) &&
IsGenericInterfaceOrDelegateTypeParameterList(targetToken.Parent.GetParent().GetParent()))
{
return(true);
}
return(false);
}
public static bool IsLiteral(this SyntaxToken token)
{
return(token.CSharpKind() == SyntaxKind.CharacterLiteralToken ||
token.CSharpKind() == SyntaxKind.FalseKeyword ||
token.CSharpKind() == SyntaxKind.NumericLiteralToken ||
token.CSharpKind() == SyntaxKind.StringLiteralToken ||
token.CSharpKind() == SyntaxKind.TrueKeyword);
}
public static bool IsPlusOrMinusExpression(this SyntaxToken token)
{
if (token.CSharpKind() != SyntaxKind.PlusToken && token.CSharpKind() != SyntaxKind.MinusToken)
{
return(false);
}
return(token.Parent is PrefixUnaryExpressionSyntax);
}
private static ValueTuple <SyntaxToken, SyntaxToken>?FindAppropriateRangeWorker(SyntaxToken endToken, bool useDefaultRange)
{
// special token that we know how to find proper starting token
switch (endToken.CSharpKind())
{
case SyntaxKind.CloseBraceToken:
{
return(FindAppropriateRangeForCloseBrace(endToken));
}
case SyntaxKind.SemicolonToken:
{
return(FindAppropriateRangeForSemicolon(endToken));
}
case SyntaxKind.ColonToken:
{
return(FindAppropriateRangeForColon(endToken));
}
default:
{
// default case
if (!useDefaultRange)
{
return(null);
}
// if given token is skipped token, don't bother to find appropriate
// starting point
if (endToken.CSharpKind() == SyntaxKind.SkippedTokensTrivia)
{
return(null);
}
var parent = endToken.Parent;
if (parent == null)
{
// if there is no parent setup yet, nothing we can do here.
return(null);
}
// if we are called due to things in trivia or literals, don't bother
// finding a starting token
if (parent.CSharpKind() == SyntaxKind.StringLiteralExpression ||
parent.CSharpKind() == SyntaxKind.CharacterLiteralExpression)
{
return(null);
}
// format whole node that containing the end token + its previous one
// to do indentation
return(ValueTuple.Create(GetPreviousTokenIfFirstTokenOnLine(parent.GetFirstToken()), parent.GetLastToken()));
}
}
}
private static ValueTuple<SyntaxToken, SyntaxToken>? FindAppropriateRangeWorker(SyntaxToken endToken, bool useDefaultRange)
{
// special token that we know how to find proper starting token
switch (endToken.CSharpKind())
{
case SyntaxKind.CloseBraceToken:
{
return FindAppropriateRangeForCloseBrace(endToken);
}
case SyntaxKind.SemicolonToken:
{
return FindAppropriateRangeForSemicolon(endToken);
}
case SyntaxKind.ColonToken:
{
return FindAppropriateRangeForColon(endToken);
}
default:
{
// default case
if (!useDefaultRange)
{
return null;
}
// if given token is skipped token, don't bother to find appropriate
// starting point
if (endToken.CSharpKind() == SyntaxKind.SkippedTokensTrivia)
{
return null;
}
var parent = endToken.Parent;
if (parent == null)
{
// if there is no parent setup yet, nothing we can do here.
return null;
}
// if we are called due to things in trivia or literals, don't bother
// finding a starting token
if (parent.CSharpKind() == SyntaxKind.StringLiteralExpression ||
parent.CSharpKind() == SyntaxKind.CharacterLiteralExpression)
{
return null;
}
// format whole node that containing the end token + its previous one
// to do indentation
return ValueTuple.Create(GetAppropriatePreviousToken(parent.GetFirstToken()), parent.GetLastToken());
}
}
}
public static bool IsLastTokenInLabelStatement(this SyntaxToken token)
{
if (token.CSharpKind() != SyntaxKind.SemicolonToken && token.CSharpKind() != SyntaxKind.CloseBraceToken)
{
return(false);
}
if (token.Parent == null)
{
return(false);
}
return(token.Parent.Parent is LabeledStatementSyntax);
}
private SyntaxToken ReplaceTokenForCref(SyntaxToken oldToken, SyntaxToken dummySameToken)
{
if (oldToken.CSharpKind() == SyntaxKind.LessThanToken)
{
return(SyntaxFactory.Token(oldToken.LeadingTrivia, SyntaxKind.LessThanToken, "{", "{", oldToken.TrailingTrivia));
}
if (oldToken.CSharpKind() == SyntaxKind.GreaterThanToken)
{
return(SyntaxFactory.Token(oldToken.LeadingTrivia, SyntaxKind.GreaterThanToken, "}", "}", oldToken.TrailingTrivia));
}
Debug.Assert(false, "This method is used only replacing the '<' and '>' to '{' and '}' respectively");
return(default(SyntaxToken));
}
private void ValidIdentifier(string identifier, bool expectedValid)
{
SyntaxToken token = SyntaxFactory.ParseToken(identifier);
Assert.AreEqual(expectedValid,
token.CSharpKind() == SyntaxKind.IdentifierToken && token.Span.Length == identifier.Length);
}
public static bool IsLastTokenOfQueryClause(this SyntaxToken token)
{
if (token.IsLastTokenOfNode <QueryClauseSyntax>())
{
return(true);
}
if (token.CSharpKind() == SyntaxKind.IdentifierToken &&
token.GetPreviousToken(includeSkipped: true).CSharpKind() == SyntaxKind.IntoKeyword)
{
return(true);
}
// Check to see if the parser has treated this as a partially typed declaration expression.
if (token.IsKind(SyntaxKind.IdentifierToken) &&
token.IsParentKind(SyntaxKind.IdentifierName) &&
token.Parent.IsParentKind(SyntaxKind.DeclarationExpression))
{
var queryClause = token.Parent.FirstAncestorOrSelf <QueryClauseSyntax>();
if (queryClause == null)
{
return(false);
}
var declarationExpression = (DeclarationExpressionSyntax)token.Parent.Parent;
if (declarationExpression.Type == token.Parent &&
declarationExpression.Variable != null &&
declarationExpression.Variable.Initializer == null)
{
return(true);
}
}
return(false);
}
public static bool IsOrderByDirectionContext(this SyntaxToken targetToken)
{
// cases:
// orderby a |
// orderby a a|
// orderby a, b |
// orderby a, b a|
if (targetToken.CSharpKind() != SyntaxKind.IdentifierToken)
{
return(false);
}
var ordering = targetToken.GetAncestor <OrderingSyntax>();
if (ordering == null)
{
return(false);
}
// orderby a |
// orderby a, b |
if (targetToken == ordering.Expression.GetLastToken(includeSkipped: true))
{
return(true);
}
return(false);
}
public static bool IsConstructorOrMethodParameterArgumentContext(this SyntaxToken targetToken)
{
// cases:
// Foo( |
// Foo(expr, |
// Foo(bar: |
// new Foo( |
// new Foo(expr, |
// new Foo(bar: |
// Foo : base( |
// Foo : base(bar: |
// Foo : this( |
// Foo : ths(bar: |
// Foo(bar: |
if (targetToken.CSharpKind() == SyntaxKind.ColonToken &&
targetToken.Parent.IsKind(SyntaxKind.NameColon) &&
targetToken.Parent.IsParentKind(SyntaxKind.Argument) &&
targetToken.Parent.GetParent().IsParentKind(SyntaxKind.ArgumentList))
{
var owner = targetToken.Parent.GetParent().GetParent().GetParent();
if (owner.IsKind(SyntaxKind.InvocationExpression) ||
owner.IsKind(SyntaxKind.ObjectCreationExpression) ||
owner.IsKind(SyntaxKind.BaseConstructorInitializer) ||
owner.IsKind(SyntaxKind.ThisConstructorInitializer))
{
return(true);
}
}
if (targetToken.CSharpKind() == SyntaxKind.OpenParenToken ||
targetToken.CSharpKind() == SyntaxKind.CommaToken)
{
if (targetToken.Parent.IsKind(SyntaxKind.ArgumentList))
{
if (targetToken.Parent.IsParentKind(SyntaxKind.InvocationExpression) ||
targetToken.Parent.IsParentKind(SyntaxKind.ObjectCreationExpression) ||
targetToken.Parent.IsParentKind(SyntaxKind.BaseConstructorInitializer) ||
targetToken.Parent.IsParentKind(SyntaxKind.ThisConstructorInitializer))
{
return(true);
}
}
}
return(false);
}
public static bool IsPreProcessorExpressionContext(this SyntaxToken targetToken)
{
// cases:
// #if |
// #if foo || |
// #if foo && |
// #if ( |
// #if ! |
// Same for elif
if (targetToken.GetAncestor <ConditionalDirectiveTriviaSyntax>() == null)
{
return(false);
}
// #if
// #elif
if (targetToken.CSharpKind() == SyntaxKind.IfKeyword ||
targetToken.CSharpKind() == SyntaxKind.ElifKeyword)
{
return(true);
}
// ( |
if (targetToken.CSharpKind() == SyntaxKind.OpenParenToken &&
targetToken.Parent.IsKind(SyntaxKind.ParenthesizedExpression))
{
return(true);
}
// ! |
if (targetToken.Parent is PrefixUnaryExpressionSyntax)
{
var prefix = targetToken.Parent as PrefixUnaryExpressionSyntax;
return(prefix.OperatorToken == targetToken);
}
// a &&
// a ||
if (targetToken.Parent is BinaryExpressionSyntax)
{
var binary = targetToken.Parent as BinaryExpressionSyntax;
return(binary.OperatorToken == targetToken);
}
return(false);
}
private void TypeChecks(TypeSymbol type, BaseFieldDeclarationSyntax fieldSyntax, VariableDeclaratorSyntax declarator, DiagnosticBag diagnostics)
{
if (type.IsStatic)
{
// Cannot declare a variable of static type '{0}'
diagnostics.Add(ErrorCode.ERR_VarDeclIsStaticClass, this.Location, type);
}
else if (type.SpecialType == SpecialType.System_Void)
{
diagnostics.Add(ErrorCode.ERR_FieldCantHaveVoidType, fieldSyntax.Declaration.Type.Location);
}
else if (type.IsRestrictedType())
{
diagnostics.Add(ErrorCode.ERR_FieldCantBeRefAny, fieldSyntax.Declaration.Type.Location, type);
}
else if (IsConst && !type.CanBeConst())
{
SyntaxToken constToken = default(SyntaxToken);
foreach (var modifier in fieldSyntax.Modifiers)
{
if (modifier.CSharpKind() == SyntaxKind.ConstKeyword)
{
constToken = modifier;
break;
}
}
Debug.Assert(constToken.CSharpKind() == SyntaxKind.ConstKeyword);
diagnostics.Add(ErrorCode.ERR_BadConstType, constToken.GetLocation(), type);
}
else
{
if (ContainingType.TypeKind == TypeKind.Struct && !IsStatic && !IsConst)
{
var initializerOpt = declarator.Initializer;
if (initializerOpt != null)
{
// '{0}': cannot have instance field initializers in structs
diagnostics.Add(ErrorCode.ERR_FieldInitializerInStruct, this.Location, this);
}
}
if (IsVolatile && !type.IsValidVolatileFieldType())
{
// '{0}': a volatile field cannot be of the type '{1}'
diagnostics.Add(ErrorCode.ERR_VolatileStruct, this.Location, this, type);
}
}
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (!this.IsNoMoreVisibleThan(type, ref useSiteDiagnostics))
{
// Inconsistent accessibility: field type '{1}' is less accessible than field '{0}'
diagnostics.Add(ErrorCode.ERR_BadVisFieldType, this.Location, this, type);
}
diagnostics.Add(this.Location, useSiteDiagnostics);
}
public static bool IsNestedQueryExpression(this SyntaxToken token)
{
var fromClause = token.Parent as FromClauseSyntax;
return(token.CSharpKind() == SyntaxKind.InKeyword &&
fromClause != null &&
fromClause.Expression is QueryExpressionSyntax);
}
public static bool IsColonInSwitchLabel(SyntaxToken token)
{
var switchLabel = token.Parent as SwitchLabelSyntax;
return(token.CSharpKind() == SyntaxKind.ColonToken &&
switchLabel != null &&
switchLabel.ColonToken == token);
}
public static bool IsColonInLabeledStatement(this SyntaxToken token)
{
var labeledStatement = token.Parent as LabeledStatementSyntax;
return(token.CSharpKind() == SyntaxKind.ColonToken &&
labeledStatement != null &&
labeledStatement.ColonToken == token);
}
public static bool IsFirstFromKeywordInExpression(this SyntaxToken token)
{
var queryExpression = token.Parent.Parent as QueryExpressionSyntax;
return(token.CSharpKind() == SyntaxKind.FromKeyword &&
queryExpression != null &&
queryExpression.GetFirstToken().Equals(token));
}
public static bool IsIdentiferInLabeledStatement(this SyntaxToken token)
{
var labeledStatement = token.Parent as LabeledStatementSyntax;
return(token.CSharpKind() == SyntaxKind.IdentifierToken &&
labeledStatement != null &&
labeledStatement.Identifier == token);
}
public static bool IsGenericGreaterThanToken(this SyntaxToken token)
{
if (token.CSharpKind() == SyntaxKind.GreaterThanToken)
{
return(token.Parent.IsKind(SyntaxKind.TypeParameterList, SyntaxKind.TypeArgumentList));
}
return(false);
}
public override SyntaxToken VisitToken(SyntaxToken token)
{
if (token.CSharpKind() == SyntaxKind.None)
{
return(token);
}
return(base.VisitToken(token).WithAdditionalAnnotations(annotation));
}
public static bool IsSemicolonInForStatement(this SyntaxToken token)
{
var forStatement = token.Parent as ForStatementSyntax;
return
(token.CSharpKind() == SyntaxKind.SemicolonToken &&
forStatement != null &&
(forStatement.FirstSemicolonToken == token || forStatement.SecondSemicolonToken == token));
}
public static bool IsCloseBraceOfExpression(this SyntaxToken token)
{
if (token.CSharpKind() != SyntaxKind.CloseBraceToken)
{
return(false);
}
return(token.Parent is ExpressionSyntax);
}
public override SyntaxToken VisitToken(SyntaxToken token)
{
if (token.CSharpKind() == SyntaxKind.None)
{
return(token);
}
return(this.nodeOrTokenMap[token].AsToken().CopyAnnotationsTo(base.VisitToken(token)));
}
public bool IsOperator(SyntaxToken token)
{
var kind = token.CSharpKind();
return
(SyntaxFacts.IsAnyUnaryExpression(kind) &&
(token.Parent is PrefixUnaryExpressionSyntax || token.Parent is PostfixUnaryExpressionSyntax)) ||
(SyntaxFacts.IsBinaryExpression(kind) && token.Parent is BinaryExpressionSyntax);
}
public override void VisitToken(SyntaxToken token)
{
if (token.CSharpKind() != SyntaxKind.None)
{
this.NodeOrTokens.Add(token);
}
base.VisitToken(token);
}
protected void AddAnchorIndentationOperation(List <AnchorIndentationOperation> list, SyntaxToken anchorToken, SyntaxToken endToken)
{
if (anchorToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
{
return;
}
list.Add(FormattingOperations.CreateAnchorIndentationOperation(anchorToken, endToken));
}
protected void AddSuppressOperation(List <SuppressOperation> list, SyntaxToken startToken, SyntaxToken endToken, SuppressOption option)
{
if (startToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
{
return;
}
list.Add(FormattingOperations.CreateSuppressOperation(startToken, endToken, option));
}
public override void VisitToken(SyntaxToken token)
{
// trivia is not considered, only the raw form of the token
this.hash = Hash.Combine((int)token.CSharpKind(), this.hash);
switch (token.CSharpKind())
{
case SyntaxKind.IdentifierToken:
this.hash = Hash.Combine(token.ValueText.GetHashCode(), this.hash);
break;
case SyntaxKind.NumericLiteralToken:
case SyntaxKind.CharacterLiteralToken:
case SyntaxKind.StringLiteralToken:
this.hash = Hash.Combine(token.ToString().GetHashCode(), this.hash);
break;
}
}
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();
}
public static bool IsUnaryOperatorContext(this SyntaxToken targetToken)
{
if (targetToken.CSharpKind() == SyntaxKind.OperatorKeyword &&
targetToken.GetPreviousToken(includeSkipped: true).IsLastTokenOfNode <TypeSyntax>())
{
return(true);
}
return(false);
}
public static bool InBetweenTwoMembers(SyntaxToken previousToken, SyntaxToken currentToken)
{
if (previousToken.CSharpKind() != SyntaxKind.SemicolonToken && previousToken.CSharpKind() != SyntaxKind.CloseBraceToken)
{
return(false);
}
if (currentToken.CSharpKind() == SyntaxKind.CloseBraceToken)
{
return(false);
}
var previousMember = GetEnclosingMember(previousToken);
var nextMember = GetEnclosingMember(currentToken);
return(previousMember != null &&
nextMember != null &&
previousMember != nextMember);
}
private static string GetClassificationForPunctuation(SyntaxToken token)
{
if (token.CSharpKind().IsOperator())
{
// special cases...
switch (token.CSharpKind())
{
case SyntaxKind.LessThanToken:
case SyntaxKind.GreaterThanToken:
// the < and > tokens of a type parameter list should be classified as
// punctuation; otherwise, they're operators.
if (token.Parent != null)
{
if (token.Parent.CSharpKind() == SyntaxKind.TypeParameterList ||
token.Parent.CSharpKind() == SyntaxKind.TypeArgumentList)
{
return(ClassificationTypeNames.Punctuation);
}
}
break;
case SyntaxKind.ColonToken:
// the : for inheritance/implements or labels should be classified as
// punctuation; otherwise, it's from a conditional operator.
if (token.Parent != null)
{
if (token.Parent.CSharpKind() != SyntaxKind.ConditionalExpression)
{
return(ClassificationTypeNames.Punctuation);
}
}
break;
}
return(ClassificationTypeNames.Operator);
}
else
{
return(ClassificationTypeNames.Punctuation);
}
}
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)
{
// * <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();
}
/// <summary>
/// Determine the classification type for a given token.
/// </summary>
/// <param name="token">The token.</param>
/// <returns>The correct syntactic classification for the token.</returns>
public static string GetClassification(SyntaxToken token)
{
if (SyntaxFacts.IsKeywordKind(token.CSharpKind()))
{
return ClassificationTypeNames.Keyword;
}
else if (SyntaxFacts.IsPunctuation(token.CSharpKind()))
{
return GetClassificationForPunctuation(token);
}
else if (token.CSharpKind() == SyntaxKind.IdentifierToken)
{
return GetClassificationForIdentifer(token);
}
else if (token.CSharpKind() == SyntaxKind.StringLiteralToken || token.CSharpKind() == SyntaxKind.CharacterLiteralToken)
{
return token.IsVerbatimStringLiteral()
? ClassificationTypeNames.VerbatimStringLiteral
: ClassificationTypeNames.StringLiteral;
}
else if (token.CSharpKind() == SyntaxKind.NumericLiteralToken)
{
return ClassificationTypeNames.NumericLiteral;
}
return null;
}
protected void AddIndentBlockOperation(
List<IndentBlockOperation> list,
SyntaxToken startToken,
SyntaxToken endToken,
IndentBlockOption option = IndentBlockOption.RelativePosition)
{
if (startToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
{
return;
}
list.Add(FormattingOperations.CreateIndentBlockOperation(startToken, endToken, indentationDelta: 1, option: option));
}
public override SyntaxToken VisitToken(SyntaxToken token)
{
switch (token.CSharpKind())
{
case SyntaxKind.OpenBraceToken:
if (token.GetPreviousToken().CSharpKind() == SyntaxKind.CloseParenToken)
{
return token.WithLeadingTrivia(SyntaxFactory.ElasticLineFeed);
}
break;
}
return token;
}
private void Add(SyntaxToken syntaxToken)
{
if (syntaxToken.CSharpKind() == SyntaxKind.IdentifierToken)
{
var identifier = syntaxToken.ValueText;
List<SyntaxToken> list;
if (!map.TryGetValue(identifier, out list))
{
list = new List<SyntaxToken>();
map.Add(identifier, list);
}
list.Add(syntaxToken);
}
}
private SourceLocalSymbol(
MethodSymbol containingMethod,
Binder binder,
TypeSyntax typeSyntax,
SyntaxToken identifierToken,
EqualsValueClauseSyntax initializer,
ExpressionSyntax collection,
LocalDeclarationKind declarationKind)
{
Debug.Assert(identifierToken.CSharpKind() != SyntaxKind.None);
Debug.Assert(declarationKind != LocalDeclarationKind.CompilerGenerated);
this.binder = binder;
this.containingMethod = containingMethod;
this.identifierToken = identifierToken;
this.typeSyntax = typeSyntax;
this.initializer = initializer;
this.collection = collection;
this.declarationKind = declarationKind;
// create this eagerly as it will always be needed for the EnsureSingleDefinition
this.locations = ImmutableArray.Create<Location>(identifierToken.GetLocation());
}
protected void AddUnindentBlockOperation(
List<IndentBlockOperation> list,
SyntaxToken startToken,
SyntaxToken endToken,
bool includeTriviaAtEnd = false,
IndentBlockOption option = IndentBlockOption.RelativePosition)
{
if (startToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
{
return;
}
if (includeTriviaAtEnd)
{
list.Add(FormattingOperations.CreateIndentBlockOperation(startToken, endToken, indentationDelta: -1, option: option));
}
else
{
var startPosition = CommonFormattingHelpers.GetStartPositionOfSpan(startToken);
var endPosition = endToken.Span.End;
list.Add(FormattingOperations.CreateIndentBlockOperation(startToken, endToken, TextSpan.FromBounds(startPosition, endPosition), indentationDelta: -1, option: option));
}
}
public static FlatValue FromLiteralToken(ITypeSymbol type, SyntaxToken token)
{
if (token.CSharpKind() == SyntaxKind.StringLiteralToken)
return new FlatValue() { ValueType = GetFlatValueType(type), Object = token.Value, ValueText = "\""+token.ValueText.Replace("\"","\\\"")+"\"" };
if (token.CSharpKind() == SyntaxKind.CharacterLiteralToken)
return new FlatValue() { ValueType = GetFlatValueType(type), Object = token.Value, ValueText = "'" + token.ValueText + "'" };
return new FlatValue() { ValueType = GetFlatValueType(type), Object = token.Value, ValueText = token.ValueText };
}
private static SyntaxToken EnsureToken(SyntaxToken token, bool prependNewLineIfMissing = false, bool appendNewLineIfMissing = false)
{
if (token.IsMissing)
{
var leadingTrivia = prependNewLineIfMissing ? token.LeadingTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed) : token.LeadingTrivia;
var trailingTrivia = appendNewLineIfMissing ? token.TrailingTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed) : token.TrailingTrivia;
return SyntaxFactory.Token(leadingTrivia, token.CSharpKind(), trailingTrivia).WithAdditionalAnnotations(Formatter.Annotation);
}
return token;
}
private void TestFunctionKeyword(SyntaxKind kind, SyntaxToken keyword)
{
Assert.NotNull(keyword);
Assert.Equal(kind, keyword.CSharpKind());
}
private SourceLocalSymbol(
Symbol containingSymbol,
Binder binder,
TypeSyntax typeSyntax,
SyntaxToken identifierToken,
LocalDeclarationKind declarationKind)
{
Debug.Assert(identifierToken.CSharpKind() != SyntaxKind.None);
Debug.Assert(declarationKind != LocalDeclarationKind.None);
this.binder = binder;
this.containingSymbol = containingSymbol;
this.identifierToken = identifierToken;
this.typeSyntax = typeSyntax;
this.declarationKind = declarationKind;
// create this eagerly as it will always be needed for the EnsureSingleDefinition
this.locations = ImmutableArray.Create<Location>(identifierToken.GetLocation());
}
public override AdjustNewLinesOperation GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
{
////////////////////////////////////////////////////
// brace related operations
// * { or * }
switch (currentToken.CSharpKind())
{
case SyntaxKind.OpenBraceToken:
if (!previousToken.IsParenInParenthesizedExpression())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
break;
case SyntaxKind.CloseBraceToken:
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// do { } while case
if (previousToken.CSharpKind() == SyntaxKind.CloseBraceToken && currentToken.CSharpKind() == SyntaxKind.WhileKeyword)
{
return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
}
// { * or } *
switch (previousToken.CSharpKind())
{
case SyntaxKind.CloseBraceToken:
if (!previousToken.IsCloseBraceOfExpression())
{
if (currentToken.CSharpKind() != SyntaxKind.SemicolonToken &&
!currentToken.IsParenInParenthesizedExpression() &&
!currentToken.IsCommaInInitializerExpression() &&
!currentToken.IsCommaInAnyArgumentsList() &&
!currentToken.IsParenInArgumentList() &&
!currentToken.IsDotInMemberAccess() &&
!currentToken.IsCloseParenInStatement())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
}
break;
case SyntaxKind.OpenBraceToken:
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.CSharpKind() == SyntaxKind.ElseKeyword && currentToken.CSharpKind() != 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.CSharpKind() == SyntaxKind.CloseParenToken && previousToken.Parent.IsEmbeddedStatementOwnerWithCloseParen())
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
if (previousToken.CSharpKind() == SyntaxKind.DoKeyword && previousToken.Parent.CSharpKind() == 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.CSharpKind() == SyntaxKind.SemicolonToken &&
(currentToken.CSharpKind() == SyntaxKind.CaseKeyword || currentToken.CSharpKind() == SyntaxKind.DefaultKeyword || currentToken.CSharpKind() == SyntaxKind.ElseKeyword))
{
return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
}
// ; * or ; * for using directive
if (previousToken.CSharpKind() == 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.CSharpKind() == 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.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;
}
private IEnumerable<ITypeSymbol> InferTypeInArgumentList(ArgumentListSyntax argumentList, SyntaxToken previousToken)
{
// Has to follow the ( or a ,
if (previousToken != argumentList.OpenParenToken && previousToken.CSharpKind() != SyntaxKind.CommaToken)
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var invocation = argumentList.Parent as InvocationExpressionSyntax;
if (invocation != null)
{
var index = this.GetArgumentListIndex(argumentList, previousToken);
return InferTypeInInvocationExpression(invocation, index);
}
var objectCreation = argumentList.Parent as ObjectCreationExpressionSyntax;
if (objectCreation != null)
{
var index = this.GetArgumentListIndex(argumentList, previousToken);
return InferTypeInObjectCreationExpression(objectCreation, index);
}
var constructorInitializer = argumentList.Parent as ConstructorInitializerSyntax;
if (constructorInitializer != null)
{
var index = this.GetArgumentListIndex(argumentList, previousToken);
return InferTypeInConstructorInitializer(constructorInitializer, index);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
protected void RemoveSuppressOperation(
List<SuppressOperation> list,
SyntaxToken startToken,
SyntaxToken endToken)
{
if (startToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
{
return;
}
var span = TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End);
for (int i = 0; i < list.Count; i++)
{
if (list[i] != null && list[i].TextSpan.Start >= span.Start && list[i].TextSpan.End <= span.End)
{
list[i] = null;
}
}
}
private IEnumerable<ITypeSymbol> InferTypeInBracketedArgumentList(BracketedArgumentListSyntax bracketedArgumentList, SyntaxToken previousToken)
{
// Has to follow the [ or a ,
if (previousToken != bracketedArgumentList.OpenBracketToken && previousToken.CSharpKind() != SyntaxKind.CommaToken)
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var elementAccess = bracketedArgumentList.Parent as ElementAccessExpressionSyntax;
if (elementAccess != null)
{
var index = GetArgumentListIndex(bracketedArgumentList, previousToken);
return InferTypeInElementAccessExpression(
elementAccess, index);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
private IEnumerable<ITypeSymbol> InferTypeInAttributeArgumentList(AttributeArgumentListSyntax attributeArgumentList, SyntaxToken previousToken)
{
// Has to follow the ( or a ,
if (previousToken != attributeArgumentList.OpenParenToken && previousToken.CSharpKind() != SyntaxKind.CommaToken)
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var attribute = attributeArgumentList.Parent as AttributeSyntax;
if (attribute != null)
{
var index = this.GetArgumentListIndex(attributeArgumentList, previousToken);
return InferTypeInAttribute(attribute, index);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
private static void ProcessExpression(OutputWriter writer, SyntaxToken operatorToken, CSharpSyntaxNode rightExpression,
CSharpSyntaxNode leftExpression)
{
TypeInfo leftExpressionType = TypeProcessor.GetTypeInfo(leftExpression ?? rightExpression);
var rightExpressionType = TypeProcessor.GetTypeInfo(rightExpression);
var boxLeft = leftExpressionType.Type != null && (leftExpressionType.Type != leftExpressionType.ConvertedType) &&
((leftExpressionType.Type.IsValueType || leftExpressionType.Type.TypeKind == TypeKind.TypeParameter) &&
(leftExpressionType.ConvertedType.IsReferenceType));
var boxRight = (rightExpressionType.ConvertedType != null &&
(rightExpressionType.Type != null &&
((rightExpressionType.Type.IsValueType ||
rightExpressionType.Type.TypeKind == TypeKind.TypeParameter) &&
(rightExpressionType.ConvertedType.IsReferenceType))))
||
(rightExpressionType.Type != null && rightExpressionType.Type.IsValueType &&
leftExpressionType.Type != null && leftExpressionType.Type.TypeKind == TypeKind.Error);
//Fix for yield ... why does it give errortypes ?
var unboxRight = rightExpressionType.ConvertedType != null &&
(rightExpressionType.Type != null && (rightExpressionType.Type.IsReferenceType &&
(rightExpressionType.ConvertedType.IsValueType)));
var rightnull = rightExpression!=null && rightExpression.ToFullString().Trim() == "null";
var leftnull = leftExpression != null && leftExpression.ToFullString().Trim() == "null";
var nullAssignment = (rightnull || leftnull);
var val = WriteOperatorDeclaration.AllBinaryOperators.FirstOrDefault(k => k.Value == operatorToken.Text);
//Matching Binary Operator Overload
if (!String.IsNullOrEmpty(val.Value))
{
//Try Left
IEnumerable<ISymbol> members = new List<ISymbol>();
if (leftExpressionType.Type != null)
members = leftExpressionType.Type.GetMembers(val.Key);
if (rightExpressionType.Type != null)
{
members = members.
Union(rightExpressionType.Type.GetMembers(val.Key));
}
var leftExpressionString = Core.WriteString(leftExpression);
if (members != null && members.Any())
{
if (!(leftExpressionType.Type.IsPrimitive() && rightExpressionType.Type.IsPrimitive()))
{
var correctOverload =
members.OfType<IMethodSymbol>()
.FirstOrDefault(
u =>
u.Parameters[0].Type == leftExpressionType.Type &&
u.Parameters[1].Type == rightExpressionType.Type);
if (correctOverload != null)
{
var name =
WriteIdentifierName.TransformIdentifier(OverloadResolver.MethodName(correctOverload));
writer.Write(TypeProcessor.ConvertType(correctOverload.ContainingType) + "." + name +
"(" +
leftExpressionString + "," + Core.WriteString(rightExpression)
+ ")");
return;
}
}
}
else
{
if (WriteOperatorDeclaration.AssignOpOperators.ContainsKey(val.Key))
{
var methodName =
WriteOperatorDeclaration.AllBinaryOperators.FirstOrDefault(
k => k.Value == val.Value.Substring(0, 1));
// emulate c# facility to use the lower op ...
//Try Left
members = null;
if (leftExpressionType.Type != null)
members = leftExpressionType.Type.GetMembers(methodName.Key);
if (rightExpressionType.Type != null)
{
members = members.
Union(rightExpressionType.Type.GetMembers(methodName.Key));
}
if (members != null && members.Any())
{
if (!(leftExpressionType.Type.IsPrimitive() && rightExpressionType.Type.IsPrimitive()))
{
var correctOverload =
members.OfType<IMethodSymbol>()
.FirstOrDefault(
u =>
u.Parameters[0].Type == leftExpressionType.Type &&
u.Parameters[1].Type == rightExpressionType.Type);
if (correctOverload != null)
{
var name =
WriteIdentifierName.TransformIdentifier(
OverloadResolver.MethodName(correctOverload));
writer.Write(leftExpressionString + " = " +
TypeProcessor.ConvertType(correctOverload.ContainingType) + "." +
name +
"(" +
leftExpressionString + "," + Core.WriteString(rightExpression)
+ ")");
return;
}
}
}
}
}
}
//Property calls will be fixed in a preprocessor step ... i.e. just call them
if (nullAssignment)
{
if (rightnull)
{
switch (operatorToken.CSharpKind())
{
case SyntaxKind.EqualsEqualsToken:
writer.Write("");
break;
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.ExclamationEqualsToken:
writer.Write("!");
break;
default:
writer.Write(operatorToken.ToString());
break;
}
writer.Write("__IsNull(");
Core.Write(writer, leftExpression);
writer.Write(")");
return;
}
if (leftnull)
{
// writer.Write("null");
//
// switch (operatorToken.CSharpKind())
// {
// case SyntaxKind.EqualsEqualsToken:
// writer.Write(" is ");
// break;
// case SyntaxKind.NotEqualsExpression:
// case SyntaxKind.ExclamationEqualsToken:
// writer.Write(" !is ");
// break;
// default:
// writer.Write(operatorToken.ToString());
// break;
// }
//
// Core.Write(writer, rightExpression);
//
// return;
switch (operatorToken.CSharpKind())
{
case SyntaxKind.EqualsEqualsToken:
writer.Write("");
break;
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.ExclamationEqualsToken:
writer.Write("!");
break;
default:
writer.Write(operatorToken.ToString());
break;
}
writer.Write("__IsNull(");
Core.Write(writer, rightExpression);
writer.Write(")");
return;
}
}
//Do we have an implicit converter, if so, use it
if (leftExpressionType.Type != rightExpressionType.Type && rightExpressionType.Type != null)
{
bool useType = true;
//We should start with exact converters and then move to more generic convertors i.e. base class or integers which are implicitly convertible
var correctConverter = leftExpressionType.Type.GetImplicitCoversionOp(leftExpressionType.Type,
rightExpressionType.Type, true);
if (correctConverter == null)
{
useType = false;
correctConverter =
rightExpressionType.Type.GetImplicitCoversionOp(leftExpressionType.Type,
rightExpressionType.Type, true);
}
if (correctConverter != null)
{
Core.Write(writer, leftExpression);
writer.Write(operatorToken.ToString());
if (useType)
{
writer.Write(TypeProcessor.ConvertType(leftExpressionType.Type) + "." + "op_Implicit_" +
TypeProcessor.ConvertType(correctConverter.ReturnType, false, true, false).Replace(".", "_"));
}
else
{
writer.Write(TypeProcessor.ConvertType(rightExpressionType.Type) + "." + "op_Implicit_" +
TypeProcessor.ConvertType(correctConverter.ReturnType, false, true, false).Replace(".", "_"));
}
writer.Write("(");
Core.Write(writer, rightExpression);
writer.Write(")");
return;
}
}
if (operatorToken.CSharpKind() == SyntaxKind.PlusEqualsToken ||
operatorToken.CSharpKind() == SyntaxKind.MinusEqualsToken)
{
var isname = rightExpression is NameSyntax;
var nameexpression = rightExpression as NameSyntax;
var ismemberexpression = rightExpression is MemberAccessExpressionSyntax ||
(isname &&
TypeProcessor.GetSymbolInfo(rightExpression as NameSyntax).Symbol.Kind ==
SymbolKind.Method);
var isdelegateassignment = rightExpressionType.ConvertedType != null && (ismemberexpression &&
rightExpressionType.ConvertedType
.TypeKind == TypeKind.Delegate);
var memberaccessexpression = rightExpression as MemberAccessExpressionSyntax;
var isstaticdelegate = isdelegateassignment &&
((memberaccessexpression != null &&
TypeProcessor.GetSymbolInfo(memberaccessexpression).Symbol.IsStatic) ||
(isname && TypeProcessor.GetSymbolInfo(nameexpression).Symbol.IsStatic));
if (isdelegateassignment)
{
Core.Write(writer, leftExpression);
writer.Write(operatorToken.ToString());
var typeString = TypeProcessor.ConvertType(rightExpressionType.ConvertedType);
if (rightExpressionType.ConvertedType.TypeKind == TypeKind.TypeParameter)
writer.Write(" __TypeNew!(" + typeString + ")(");
else
writer.Write("new " + typeString + "(");
var isStatic = isstaticdelegate;
// if (isStatic)
// writer.Write("__ToDelegate(");
MemberUtilities.WriteMethodPointer(writer, rightExpression);
// if (isStatic)
// writer.Write(")");
writer.Write(")");
return;
}
}
if (leftExpressionType.Type == null || (rightExpressionType.Type == null && rightExpression!=null))
{
// seems we have a null here obj==null or null==obj
if ((rightExpressionType.Type != null && rightExpressionType.Type.IsValueType) ||
(leftExpressionType.Type != null && leftExpressionType.Type.IsValueType))
{
writer.Write("/*value type cannot be null*/");
Core.Write(writer, leftExpression);
switch (operatorToken.CSharpKind())
{
case SyntaxKind.EqualsEqualsToken:
writer.Write("!=");
break;
case SyntaxKind.NotEqualsExpression:
writer.Write("==");
break;
default:
writer.Write(operatorToken.ToString());
break;
}
Core.Write(writer, rightExpression);
}
else
{
Core.Write(writer, leftExpression);
if (operatorToken.CSharpKind() == SyntaxKind.EqualsEqualsToken)
writer.Write(" is ");
else if (operatorToken.CSharpKind() == SyntaxKind.ExclamationEqualsToken)
writer.Write(" !is ");
else
writer.Write(operatorToken.ToString());
if (rightExpression != null)
Core.Write(writer, rightExpression);
}
}
else
{
writer.Write(boxLeft ? "BOX!(" + TypeProcessor.ConvertType(leftExpressionType.Type) + ")(" : "");
Core.Write(writer, leftExpression);
writer.Write(boxLeft ? ")" : "");
writer.Write(operatorToken.ToString());
if (rightExpression != null)
{
writer.Write(unboxRight
? "UNBOX!(" + TypeProcessor.ConvertType(rightExpressionType.ConvertedType) + ")("
: "");
writer.Write(boxRight ? "BOX!(" + TypeProcessor.ConvertType(rightExpressionType.Type) + ")(" : "");
Core.Write(writer, rightExpression);
writer.Write(boxRight ? ")" : "");
writer.Write(unboxRight ? ")" : "");
}
}
}
public static bool ParenOrBracketContainsNothing(this SyntaxToken token1, SyntaxToken token2)
{
return (token1.CSharpKind() == SyntaxKind.OpenParenToken && token2.CSharpKind() == SyntaxKind.CloseParenToken) ||
(token1.CSharpKind() == SyntaxKind.OpenBracketToken && token2.CSharpKind() == SyntaxKind.CloseBracketToken);
}
public override SyntaxToken VisitToken(SyntaxToken token)
{
return SyntaxFactory.MissingToken(token.CSharpKind());
}
private static int LineBreaksAfterSemicolon(SyntaxToken previousToken, SyntaxToken currentToken)
{
if (previousToken.Parent is ForStatementSyntax)
{
return 0;
}
else if (currentToken.CSharpKind() == SyntaxKind.CloseBraceToken)
{
return 1;
}
else if (previousToken.Parent is UsingDirectiveSyntax)
{
return currentToken.Parent is UsingDirectiveSyntax ? 1 : 2;
}
else if (previousToken.Parent is ExternAliasDirectiveSyntax)
{
return currentToken.Parent is ExternAliasDirectiveSyntax ? 1 : 2;
}
else
{
return 1;
}
}
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;
}
private static int LineBreaksAfterCloseBrace(SyntaxToken nextToken)
{
if (nextToken.CSharpKind() == SyntaxKind.CloseBraceToken)
{
return 1;
}
else if (
nextToken.CSharpKind() == SyntaxKind.CatchKeyword ||
nextToken.CSharpKind() == SyntaxKind.FinallyKeyword ||
nextToken.CSharpKind() == SyntaxKind.ElseKeyword)
{
return 1;
}
else if (
nextToken.CSharpKind() == SyntaxKind.WhileKeyword &&
nextToken.Parent.CSharpKind() == SyntaxKind.DoStatement)
{
return 1;
}
else if (nextToken.CSharpKind() == SyntaxKind.EndOfFileToken)
{
return 0;
}
else
{
return 2;
}
}
// copied from compiler formatter to have same base forced format
private int LineBreaksAfter(SyntaxToken previousToken, SyntaxToken currentToken)
{
if (currentToken.CSharpKind() == SyntaxKind.None)
{
return 0;
}
switch (previousToken.CSharpKind())
{
case SyntaxKind.None:
return 0;
case SyntaxKind.OpenBraceToken:
case SyntaxKind.FinallyKeyword:
return 1;
case SyntaxKind.CloseBraceToken:
return LineBreaksAfterCloseBrace(currentToken);
case SyntaxKind.CloseParenToken:
return (((previousToken.Parent is StatementSyntax) && currentToken.Parent != previousToken.Parent)
|| currentToken.CSharpKind() == SyntaxKind.OpenBraceToken) ? 1 : 0;
case SyntaxKind.CloseBracketToken:
if (previousToken.Parent is AttributeListSyntax)
{
// Assembly and module-level attributes followed by non-attributes should have
// a blank line after them.
var parent = (AttributeListSyntax)previousToken.Parent;
if (parent.Target != null &&
(parent.Target.Identifier.IsKindOrHasMatchingText(SyntaxKind.AssemblyKeyword) ||
parent.Target.Identifier.IsKindOrHasMatchingText(SyntaxKind.ModuleKeyword)))
{
if (!(currentToken.Parent is AttributeListSyntax))
{
return 2;
}
}
if (previousToken.GetAncestor<ParameterSyntax>() == null)
{
return 1;
}
}
break;
case SyntaxKind.SemicolonToken:
return LineBreaksAfterSemicolon(previousToken, currentToken);
case SyntaxKind.CommaToken:
return previousToken.Parent is EnumDeclarationSyntax ? 1 : 0;
case SyntaxKind.ElseKeyword:
return currentToken.CSharpKind() != SyntaxKind.IfKeyword ? 1 : 0;
case SyntaxKind.ColonToken:
if (previousToken.Parent is LabeledStatementSyntax || previousToken.Parent is SwitchLabelSyntax)
{
return 1;
}
break;
}
if ((currentToken.CSharpKind() == SyntaxKind.FromKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.FromClause) ||
(currentToken.CSharpKind() == SyntaxKind.LetKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.LetClause) ||
(currentToken.CSharpKind() == SyntaxKind.WhereKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.WhereClause) ||
(currentToken.CSharpKind() == SyntaxKind.JoinKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.JoinClause) ||
(currentToken.CSharpKind() == SyntaxKind.JoinKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.JoinIntoClause) ||
(currentToken.CSharpKind() == SyntaxKind.OrderByKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.OrderByClause) ||
(currentToken.CSharpKind() == SyntaxKind.SelectKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.SelectClause) ||
(currentToken.CSharpKind() == SyntaxKind.GroupKeyword && currentToken.Parent.CSharpKind() == SyntaxKind.GroupClause))
{
return 1;
}
switch (currentToken.CSharpKind())
{
case SyntaxKind.OpenBraceToken:
case SyntaxKind.CloseBraceToken:
case SyntaxKind.ElseKeyword:
case SyntaxKind.FinallyKeyword:
return 1;
case SyntaxKind.OpenBracketToken:
if (currentToken.Parent is AttributeListSyntax)
{
// Assembly and module-level attributes preceded by non-attributes should have
// a blank line separating them.
var parent = (AttributeListSyntax)currentToken.Parent;
if (parent.Target != null)
{
if (parent.Target.Identifier == SyntaxFactory.Token(SyntaxKind.AssemblyKeyword) ||
parent.Target.Identifier == SyntaxFactory.Token(SyntaxKind.ModuleKeyword))
{
if (!(previousToken.Parent is AttributeListSyntax))
{
return 2;
}
}
}
// Attributes on parameters should have no lines between them.
if (parent.Parent is ParameterSyntax)
{
return 0;
}
return 1;
}
break;
case SyntaxKind.WhereKeyword:
return previousToken.Parent is TypeParameterListSyntax ? 1 : 0;
}
return 0;
}
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();
}
