private static SyntaxNode SimplifyName(
SyntaxNode node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
SyntaxNode replacementNode;
TextSpan issueSpan;
if (node.Kind() == SyntaxKind.QualifiedCref)
{
var crefSyntax = (QualifiedCrefSyntax)node;
if (!crefSyntax.TryReduceOrSimplifyExplicitName(semanticModel, out var crefReplacement, out issueSpan, optionSet, cancellationToken))
{
return(node);
}
replacementNode = crefReplacement;
}
else
{
var expressionSyntax = (ExpressionSyntax)node;
if (!expressionSyntax.TryReduceOrSimplifyExplicitName(semanticModel, out var expressionReplacement, out issueSpan, optionSet, cancellationToken))
{
return(node);
}
replacementNode = expressionReplacement;
}
node = node.CopyAnnotationsTo(replacementNode).WithAdditionalAnnotations(Formatter.Annotation);
return(node.WithoutAnnotations(Simplifier.Annotation));
}
private static SyntaxNode SimplifyName(
SyntaxNode node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
SyntaxNode replacementNode;
if (node.IsKind(SyntaxKind.QualifiedCref, out QualifiedCrefSyntax crefSyntax))
{
if (!QualifiedCrefSimplifier.Instance.TrySimplify(
crefSyntax, semanticModel, optionSet,
out var crefReplacement, out _, cancellationToken))
{
return(node);
}
replacementNode = crefReplacement;
}
else
{
var expressionSyntax = (ExpressionSyntax)node;
if (!ExpressionSimplifier.Instance.TrySimplify(expressionSyntax, semanticModel, optionSet, out var expressionReplacement, out _, cancellationToken))
{
return(node);
}
replacementNode = expressionReplacement;
}
node = node.CopyAnnotationsTo(replacementNode).WithAdditionalAnnotations(Formatter.Annotation);
return(node.WithoutAnnotations(Simplifier.Annotation));
}
private static SyntaxNode SimplifyName(
SyntaxNode node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
SyntaxNode replacementNode;
TextSpan issueSpan;
if (node.Kind() == SyntaxKind.QualifiedCref)
{
var crefSyntax = (QualifiedCrefSyntax)node;
if (!crefSyntax.TryReduceOrSimplifyExplicitName(semanticModel, out var crefReplacement, out issueSpan, optionSet, cancellationToken))
{
return node;
}
replacementNode = crefReplacement;
}
else
{
var expressionSyntax = (ExpressionSyntax)node;
if (!expressionSyntax.TryReduceOrSimplifyExplicitName(semanticModel, out var expressionReplacement, out issueSpan, optionSet, cancellationToken))
{
return node;
}
replacementNode = expressionReplacement;
}
node = node.CopyAnnotationsTo(replacementNode).WithAdditionalAnnotations(Formatter.Annotation);
return node.WithoutAnnotations(Simplifier.Annotation);
}
public T Accept(SyntaxNode node, bool addSourceMapping)
{
try {
var converted = _wrappedVisitor.Visit(node);
return(addSourceMapping ? node.CopyAnnotationsTo(converted).WithSourceMappingFrom(node)
: WithoutSourceMapping(converted));
} catch (Exception e) {
var dummyStatement = SyntaxFactory.EmptyStatement();
return(((T)(object)dummyStatement).WithVbTrailingErrorComment((CSharpSyntaxNode)node, e));
}
}
private static T WithAnnotations<T>(SyntaxNode sourceNode, T destination) where T : SyntaxNode
{
destination = sourceNode.CopyAnnotationsTo(destination);
var sourceChildAnnotations = new HashSet<SyntaxAnnotation>(sourceNode.ChildNodes()
.SelectMany(n => n.GetAnnotations(AnnotationConstants.SelectedNodeAnnotationKind)));
foreach (var annotation in destination.ChildNodes().SelectMany(n => n.GetAnnotations(AnnotationConstants.SelectedNodeAnnotationKind))) {
sourceChildAnnotations.Remove(annotation);
}
return destination.WithAdditionalAnnotations(sourceChildAnnotations);
}
/// <remarks>
/// If lots of special cases, move to wrapping the wrappedVisitor in another visitor, but I'd rather use a simple switch here initially.
/// </remarks>
private static T WithSourceMapping <T>(SyntaxNode vbNode, T converted) where T : CS.CSharpSyntaxNode
{
switch (vbNode)
{
case VBSyntax.CompilationUnitSyntax vbCus when converted is CSSyntax.CompilationUnitSyntax csCus:
converted = (T)(object)csCus.WithEndOfFileToken(
csCus.EndOfFileToken.WithConvertedLeadingTriviaFrom(vbCus.EndOfFileToken).WithSourceMappingFrom(vbCus.EndOfFileToken)
);
break;
}
return(vbNode.CopyAnnotationsTo(converted).WithVbSourceMappingFrom(vbNode));
}
private static SyntaxList <T> WithSourceMappingFrom <T>(this SyntaxList <T> converted, SyntaxNode node) where T : SyntaxNode
{
if (!converted.Any())
{
return(converted);
}
var origLinespan = node.SyntaxTree.GetLineSpan(node.Span);
var first = converted.First();
converted = converted.Replace(first, node.CopyAnnotationsTo(first).WithSourceStartLineAnnotation(origLinespan));
var last = converted.Last();
return(converted.Replace(last, last.WithSourceEndLineAnnotation(origLinespan)));
}
/// <remarks>
/// If lots of special cases, move to wrapping the wrappedVisitor in another visitor, but I'd rather use a simple switch here initially.
/// </remarks>
private static T WithSourceMapping <T>(SyntaxNode vbNode, T converted) where T : CS.CSharpSyntaxNode
{
converted = vbNode.CopyAnnotationsTo(converted);
switch (vbNode)
{
case VBSyntax.CompilationUnitSyntax vbCus when converted is CSSyntax.CompilationUnitSyntax csCus:
return((T)(object)csCus
.WithSourceStartLineAnnotation(vbNode.SyntaxTree.GetLineSpan(new TextSpan(0, 0)))
.WithEndOfFileToken(csCus.EndOfFileToken
.WithConvertedLeadingTriviaFrom(vbCus.EndOfFileToken).WithSourceMappingFrom(vbCus.EndOfFileToken)
));
}
return(converted.WithVbSourceMappingFrom(vbNode));
}
/// <remarks>
/// If lots of special cases, move to wrapping the wrappedVisitor in another visitor, but I'd rather use a simple switch here initially.
/// </remarks>
private static T WithSourceMapping(SyntaxNode csNode, T converted)
{
switch (csNode)
{
case CSSyntax.AttributeListSyntax _:
converted = converted.WithPrependedLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed);
break;
case CSSyntax.CompilationUnitSyntax csCus when converted is VBSyntax.CompilationUnitSyntax vbCus:
converted = (T)(object)vbCus.WithEndOfFileToken(
vbCus.EndOfFileToken.WithConvertedLeadingTriviaFrom(csCus.EndOfFileToken).WithSourceMappingFrom(csCus.EndOfFileToken)
);
break;
}
return(csNode.CopyAnnotationsTo(converted).WithCsSourceMappingFrom(csNode));
}
/// <remarks>
/// If lots of special cases, move to wrapping the wrappedVisitor in another visitor, but I'd rather use a simple switch here initially.
/// </remarks>
private static T WithSourceMapping <T>(SyntaxNode vbNode, T converted) where T : CSharpSyntaxNode
{
converted = vbNode.CopyAnnotationsTo(converted);
switch (vbNode)
{
case VBSyntax.CompilationUnitSyntax vbCus when converted is CSSyntax.CompilationUnitSyntax csCus:
return((T)(object)csCus
.WithSourceStartLineAnnotation(vbNode.SyntaxTree.GetLineSpan(new TextSpan(0, 0)))
.WithEndOfFileToken(csCus.EndOfFileToken
.WithConvertedLeadingTriviaFrom(vbCus.EndOfFileToken).WithSourceMappingFrom(vbCus.EndOfFileToken)
));
case VBSyntax.XmlElementSyntax vbXes when converted is CSSyntax.ExpressionSyntax csXes:
var lastToken = csXes.GetLastToken();
return((T)(object)csXes
.ReplaceToken(lastToken, lastToken.WithConvertedLeadingTriviaFrom(vbXes.EndTag.GetFirstToken()))
.WithConvertedLeadingTriviaFrom(vbXes.GetFirstToken())
.WithConvertedTrailingTriviaFrom(vbXes.GetLastToken()));
}
return(converted.WithVbSourceMappingFrom(vbNode));
}
public static TNode CopyAnnotations <TNode>(SyntaxNode from, TNode to) where TNode : SyntaxNode
{
// Because we are removing a node that may have annotations (i.e. formatting), we need
// to copy those annotations to the new node. However, we can only copy all annotations
// which will mean that the new node will include a ParenthesesSimplification annotation,
// even if didn't have one before. That results in potentially removing parentheses that
// weren't annotated by the user. To address this, we add *another* annotation to indicate
// that the new node shouldn't be simplified. This is to work around the
// fact that there is no way to remove an annotation from a node in the current API. If
// that gets added, we can clean this up.
var dontSimplifyResult = !to.HasAnnotation(Simplifier.Annotation);
to = from.CopyAnnotationsTo(to);
if (dontSimplifyResult)
{
to = to.WithAdditionalAnnotations(DontSimplifyAnnotation);
}
return(to);
}
private static T CopyAnnotationsFrom <T>(T node, SyntaxNode other) where T : SyntaxNode
{
return(other.CopyAnnotationsTo(node));
}
