| public Lookup ( SyntaxKind syntaxKind ) : LanguageElement | ||
| syntaxKind | SyntaxKind | |
| return | LanguageElement | |
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);
}
}
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);
}
//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);
}
