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(); }