public static TSyntax BuildTypeParameterSyntax <TSyntax>(IHasTypeParameters itemAsT, TSyntax node, WhitespaceKindLookup whitespaceLookup, Func <TSyntax, TypeParameterListSyntax, TSyntax> addTypeParameters, Func <TSyntax, SyntaxList <TypeParameterConstraintClauseSyntax>, TSyntax> addTypeParameterConstraints) where TSyntax : SyntaxNode { // This works oddly because it uncollapses the list // This code is largely repeated in interface and class factories, but is very hard to refactor because of shallow Roslyn (Microsoft) architecture var typeParamsAndConstraints = itemAsT.TypeParameters .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); var typeParameterSyntaxList = BuildSyntaxHelpers.GetTypeParameterSyntaxList( typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup); if (typeParameterSyntaxList != null) { node = addTypeParameters(node, typeParameterSyntaxList); var clauses = BuildSyntaxHelpers.GetTypeParameterConstraintList( typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup); if (clauses.Any()) { node = addTypeParameterConstraints(node, clauses); } } return(node); }
public static StatementSyntax BuildStatement(IEnumerable<IStatement> statements, IStatementBlock parent, WhitespaceKindLookup whitespaceLookup) { StatementSyntax statementBlock; var statementSyntaxList = statements .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); var hasBlock = parent.HasBlock; if (hasBlock || statements.Count() > 1) { statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList)); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); // Block tokens are held in parent } else if (statements.Count() == 1) { statementBlock = (StatementSyntax)statementSyntaxList.First(); //statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } else { statementBlock = SyntaxFactory.EmptyStatement(); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } return statementBlock; }
public static SyntaxList <TypeParameterConstraintClauseSyntax> GetTypeParameterConstraintList( IEnumerable <SyntaxNode> typeParamsAndConstraints, Whitespace2Collection whitespace2Set, WhitespaceKindLookup whitespaceLookup) { var typeParameters = typeParamsAndConstraints .OfType <TypeParameterSyntax>() .ToList(); var typeConstraintClauses = typeParamsAndConstraints .OfType <TypeParameterConstraintClauseSyntax>() .ToList(); var clauses = new List <TypeParameterConstraintClauseSyntax>(); foreach (var typeParameter in typeParameters) { var name = typeParameter.Identifier.ToString(); var constraint = typeConstraintClauses .Where(x => x.Name.ToString() == name && x.Constraints.Any()) .ToList() .SingleOrDefault(); if (constraint != null) { clauses.Add(constraint); } } return(SyntaxFactory.List(clauses)); }
internal T AttachWhitespace <T>(T syntaxNode, Whitespace2Collection whitespace2Set, WhitespaceKindLookup whitespaceLookup, LanguagePart languagePart) where T : SyntaxNode { var ret = syntaxNode; var whitespaceList = whitespace2Set.Where(x => x.LanguagePart == languagePart); var missingWhitespace = whitespaceLookup.NotUsedInWhitespaceList(whitespaceList); whitespaceList = whitespaceList .Union(missingWhitespace .Select(x => new Whitespace2(languagePart, x))); foreach (var whitespace in whitespaceList) { ret = AttachWhitespaceItem(ret, whitespace, whitespaceLookup); } // Not sure the functional approah is best here ret = CheckToken <T>(ret, x => x.GetLastToken(), t => t.TrailingTrivia, s => SyntaxFactory.ParseTrailingTrivia(s), (t, trivia) => t.WithTrailingTrivia(trivia), whitespace2Set.ForceTrailing); ret = CheckToken <T>(ret, x => x.GetFirstToken(), t => t.LeadingTrivia, s => SyntaxFactory.ParseLeadingTrivia(s), (t, trivia) => t.WithLeadingTrivia(trivia), whitespace2Set.ForceLeading); return(ret); }
public static StatementSyntax BuildStatement(IEnumerable <IStatement> statements, IStatementBlock parent, WhitespaceKindLookup whitespaceLookup) { StatementSyntax statementBlock; var statementSyntaxList = statements .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); var hasBlock = parent.HasBlock; if (hasBlock || statements.Count() > 1) { statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList)); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); // Block tokens are held in parent } else if (statements.Count() == 1) { statementBlock = (StatementSyntax)statementSyntaxList.First(); //statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } else { statementBlock = SyntaxFactory.EmptyStatement(); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } return(statementBlock); }
private bool StoreWhitespaceForChildren(IDom newItem, SyntaxNode syntaxNode, LanguagePart languagePart, WhitespaceKindLookup whitespaceLookup, bool lookForIdentifier) { foreach (var token in syntaxNode.ChildTokens()) { var kind = token.CSharpKind(); var languageElement = whitespaceLookup.Lookup(kind); if (languageElement == LanguageElement.Identifier) { lookForIdentifier = false; } if (languageElement != LanguageElement.NotApplicable) { StoreWhitespaceForToken(newItem, token, languagePart, languageElement); } } return(lookForIdentifier); }
public static TypeParameterListSyntax GetTypeParameterSyntaxList( IEnumerable <SyntaxNode> typeParamsAndConstraints, Whitespace2Collection whitespace2Set, WhitespaceKindLookup whitespaceLookup) { var typeParameters = typeParamsAndConstraints .OfType <TypeParameterSyntax>() .ToList(); if (typeParameters.Any()) { var typeParameterListSyntax = SyntaxFactory.TypeParameterList( SyntaxFactory.SeparatedList <TypeParameterSyntax>(typeParameters)); typeParameterListSyntax = AttachWhitespace( typeParameterListSyntax, whitespace2Set, whitespaceLookup); return(typeParameterListSyntax);; } return(null); }
protected override SyntaxNode AdjustWhitespace(SyntaxNode node, RDomForStatement item, WhitespaceKindLookup WhitespaceLookup) { var itemAsT = item as RDomForStatement; var syntax = node as ForStatementSyntax; //var origToken = syntax.FirstSemicolonToken; //var newToken = BuildSyntaxHelpers.AttachWhitespaceToToken(origToken , // item.Whitespace2Set[LanguagePart.Variable, LanguageElement.EndOfLine]); //syntax = syntax.ReplaceToken(origToken, newToken); var origNode = syntax.Incrementors.First(); var newNode = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(origNode, item.Whitespace2Set[LanguagePart.Iterator, LanguageElement.Identifier]); syntax = syntax.ReplaceNode(origNode, newNode); //origToken = syntax.SecondSemicolonToken; //newToken = BuildSyntaxHelpers.AttachWhitespaceToToken(origToken, // item.Whitespace2Set[LanguagePart.Variable, LanguageElement.EndOfLine]); //syntax = syntax.ReplaceToken(origToken, newToken); return(syntax); }
public static T AttachWhitespace <T>(T syntaxNode, Whitespace2Collection whitespace2Set, WhitespaceKindLookup whitespaceLookup, LanguagePart languagePart) where T : SyntaxNode { return(triviaManager.AttachWhitespace(syntaxNode, whitespace2Set, whitespaceLookup, languagePart)); }
public void StoreWhitespace(IDom newItem, SyntaxNode syntaxNode, LanguagePart languagePart, WhitespaceKindLookup whitespaceLookup) { triviaManager.StoreWhitespace(newItem, syntaxNode, languagePart, whitespaceLookup); }
//private T AttachWhitespaceItem<T>(T syntaxNode, Whitespace2 whitespace, // WhitespaceKindLookup whitespaceLookup) // where T : SyntaxNode //{ // var ret = syntaxNode; // var kind = whitespaceLookup.Lookup(whitespace.LanguageElement); // var tokens = syntaxNode.ChildTokens().Where(x => x.CSharpKind() == kind); // if (!tokens.Any() && whitespace.LanguageElement == LanguageElement.Identifier) // { // var nameNode = syntaxNode.ChildNodes().OfType<NameSyntax>().FirstOrDefault(); // if (nameNode != null) // { // tokens = nameNode.DescendantTokens() // .Where(x => x.CSharpKind() == kind); // tokens = tokens // .Where(x => !x.TrailingTrivia.Any(y => RealWhitespace(y))); // tokens = tokens // .Where(x => !x.LeadingTrivia.Any(y => RealWhitespace(y))); // } // } // else if (!tokens.Any() && whitespace.LanguageElement == LanguageElement.LastToken) // { // var typeNode = syntaxNode.ChildNodes().OfType<NameSyntax>().LastOrDefault(); // if (typeNode != null) // { // tokens = typeNode.DescendantTokens() // .Where(x => x.CSharpKind() == SyntaxKind.IdentifierToken) // .Where(x => !x.TrailingTrivia.Any(y => RealWhitespace(y))) // .Where(x => !x.LeadingTrivia.Any(y => RealWhitespace(y))); // } // } // Sometimes the token won't be there due to changes in the tree. // tokens = tokens.ToList(); // if (tokens.Any()) // { // var newToken = tokens.First(); // var leadingTrivia = SyntaxFactory.ParseLeadingTrivia(whitespace.LeadingWhitespace) // .Concat(newToken.LeadingTrivia); // var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(whitespace.TrailingWhitespace) // .Concat(newToken.TrailingTrivia); // // Manage EOL comment here // newToken = newToken // .WithLeadingTrivia(leadingTrivia) // .WithTrailingTrivia(trailingTrivia); // ret = ret.ReplaceToken(tokens.First(), newToken); // } // return ret; //} private T AttachWhitespaceItem <T>(T syntaxNode, Whitespace2 whitespace, WhitespaceKindLookup whitespaceLookup) where T : SyntaxNode { var ret = syntaxNode; var name = ret.ToString(); var kind = whitespaceLookup.Lookup(whitespace.LanguageElement); Func <SyntaxNode, IEnumerable <SyntaxToken> > makeTokens = s => s.ChildTokens().Where(x => x.CSharpKind() == kind); var tokens = makeTokens(syntaxNode).ToList(); if (!tokens.Any()) { if (whitespace.LanguageElement == LanguageElement.Identifier) { makeTokens = s => s.ChildNodes().OfType <NameSyntax>() .SelectMany(n => n.DescendantTokens() .Where(x => x.CSharpKind() == kind)); tokens = makeTokens(syntaxNode).ToList(); if (!tokens.Any() && syntaxNode.ChildTokens().Any()) { var testNode = syntaxNode.ChildTokens().First(); if (Mappings.IsTypeAlias(testNode.CSharpKind())) { tokens.Add(testNode); } } } else if (whitespace.LanguageElement == LanguageElement.LastToken) { makeTokens = s => s.ChildNodes().OfType <NameSyntax>() .SelectMany(n => n.DescendantTokens() .Where(x => x.CSharpKind() == SyntaxKind.IdentifierToken)); tokens = makeTokens(syntaxNode).ToList(); } // Sometimes the token won't be there due to changes in the tree. } if (tokens.Any()) { var token = tokens.First(); var tokenString = token.ToString(); var triviaString = token.LeadingTrivia.ToFullString(); if (whitespace.LeadingWhitespace == null) { triviaString = triviaString.Length > 0 || token.CSharpKind() == SyntaxKind.SemicolonToken ? triviaString : " "; } else if (whitespace.LeadingWhitespace.Length > triviaString.Length) { triviaString = whitespace.LeadingWhitespace; } var leadingTrivia = SyntaxFactory.ParseLeadingTrivia(triviaString); token = token.WithLeadingTrivia(leadingTrivia); if (tokens.First().Parent != null && tokens.First().Parent.AncestorsAndSelf().Any(x => x.CSharpKind() == SyntaxKind.QualifiedName)) { ret = ret.ReplaceToken(tokens.First(), token); tokens = makeTokens(ret).ToList(); token = tokens.Last(); triviaString = token.TrailingTrivia.ToFullString(); if (whitespace.TrailingWhitespace != null && whitespace.TrailingWhitespace.Length > triviaString.Length) { triviaString = whitespace.TrailingWhitespace; } var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(triviaString); token = token.WithTrailingTrivia(trailingTrivia); ret = ret.ReplaceToken(tokens.Last(), token); } else { triviaString = token.TrailingTrivia.ToFullString(); if (whitespace.TrailingWhitespace != null && whitespace.TrailingWhitespace.Length > triviaString.Length) { triviaString = whitespace.TrailingWhitespace; } var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(triviaString); token = token.WithTrailingTrivia(trailingTrivia); ret = ret.ReplaceToken(tokens.First(), token); } // Manage EOL comment here } return(ret); }
internal T AttachWhitespace <T>(T syntaxNode, Whitespace2Collection whitespace2Set, WhitespaceKindLookup whitespaceLookup) where T : SyntaxNode { return(AttachWhitespace(syntaxNode, whitespace2Set, whitespaceLookup, LanguagePart.Current)); }
internal void StoreWhitespace(IDom newItem, SyntaxNode syntaxNode, LanguagePart languagePart, WhitespaceKindLookup whitespaceLookup) { if (syntaxNode == null) { return; } // For now, all expressions are held as strings, so we just care about first/last var nodeAsTypeSyntax = syntaxNode as TypeSyntax; if (nodeAsTypeSyntax != null) { StoreWhitespaceForType(newItem, nodeAsTypeSyntax, languagePart); return; } else { // For now, all expressions are held as strings, so we just care about first/last var nodeAsExpressionSyntax = syntaxNode as ExpressionSyntax; if (nodeAsExpressionSyntax != null) { StoreWhitespaceForExpression(newItem, nodeAsExpressionSyntax, languagePart); //return; } } var lookForIdentifier = whitespaceLookup.Lookup(LanguageElement.Identifier) != SyntaxKind.None; lookForIdentifier = StoreWhitespaceForChildren(newItem, syntaxNode, languagePart, whitespaceLookup, lookForIdentifier); if (lookForIdentifier) { StoreWhitespaceForIdentifierNode(newItem, syntaxNode, languagePart); } }
protected virtual SyntaxNode AdjustWhitespace(SyntaxNode node, T item, WhitespaceKindLookup WhitespaceLookup) { return(node); }