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