private async Task <T> ConvertHandled <T>(SyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
{
try {
var converted = (T)await _wrappedVisitor.Visit(vbNode);
return(sourceTriviaMap == SourceTriviaMapKind.None || _syntaxTree != vbNode.SyntaxTree
? converted.WithoutSourceMapping()
: sourceTriviaMap == SourceTriviaMapKind.SubNodesOnly
? converted
: WithSourceMapping(vbNode, converted));
} catch (Exception e) {
var dummyStatement = (T)(object)CS.SyntaxFactory.EmptyStatement();
return(dummyStatement.WithCsTrailingErrorComment((VBasic.VisualBasicSyntaxNode)vbNode, e));
}
}
private async Task <T> ConvertHandledAsync <T>(SyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
{
try {
var converted = (T)await _wrappedVisitor.Visit(vbNode);
return(sourceTriviaMap == SourceTriviaMapKind.None || _syntaxTree != vbNode.SyntaxTree
? converted.WithoutSourceMapping()
: sourceTriviaMap == SourceTriviaMapKind.SubNodesOnly
? converted
: WithSourceMapping(vbNode, converted));
} catch (Exception e) when(typeof(T).IsAssignableFrom(typeof(CSSyntax.EmptyStatementSyntax)))
{
var dummyStatement = (T)(object)CS.SyntaxFactory.EmptyStatement();
return(dummyStatement.WithCsTrailingErrorComment((VBasic.VisualBasicSyntaxNode)vbNode, e));
} catch (Exception e) when(!(e is ExceptionWithNodeInformation))
{
throw e.WithNodeInformation(vbNode);
}
}
public SyntaxToken ConvertIdentifier(SyntaxToken id, SourceTriviaMapKind sourceTriviaMapKind = SourceTriviaMapKind.All)
{
var parent = (CS.CSharpSyntaxNode)id.Parent;
var idText = AdjustIfEventIdentifier(id.ValueText, parent);
// Underscore is a special character in VB lexer which continues lines - not sure where to find the whole set of other similar tokens if any
// Rather than a complicated contextual rename, just add an extra dash to all identifiers and hope this method is consistently used
bool keywordRequiresEscaping = id.IsKind(CSSyntaxKind.IdentifierToken) && KeywordRequiresEscaping(id);
switch (CSharpExtensions.Kind(id))
{
case CSSyntaxKind.GlobalKeyword:
idText = "Global";
break;
case CSSyntaxKind.ThisKeyword:
idText = "Item";
break;
}
var identifier = Identifier(idText, keywordRequiresEscaping);
return(id.SyntaxTree == _semanticModel.SyntaxTree && sourceTriviaMapKind != SourceTriviaMapKind.None ? identifier.WithSourceMappingFrom(id) : identifier);
}
public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, SourceTriviaMapKind sourceTriviaMapKind = SourceTriviaMapKind.All)
{
string text = id.ValueText;
if (id.SyntaxTree == SemanticModel.SyntaxTree)
{
var idSymbol = SemanticModel.GetSymbolInfo(id.Parent).Symbol ?? SemanticModel.GetDeclaredSymbol(id.Parent);
if (idSymbol != null && !String.IsNullOrWhiteSpace(idSymbol.Name))
{
text = WithDeclarationName(id, idSymbol, text);
var normalizedText = text.WithHalfWidthLatinCharacters();
if (idSymbol.IsConstructor() && isAttribute)
{
text = idSymbol.ContainingType.Name;
if (normalizedText.EndsWith("Attribute", StringComparison.OrdinalIgnoreCase))
{
text = text.Remove(text.Length - "Attribute".Length);
}
}
else if (idSymbol.IsKind(SymbolKind.Parameter) && idSymbol.ContainingSymbol.IsAccessorWithValueInCsharp() && ((idSymbol.IsImplicitlyDeclared && idSymbol.Name.WithHalfWidthLatinCharacters().Equals("value", StringComparison.OrdinalIgnoreCase)) || idSymbol.Equals(idSymbol.ContainingSymbol.GetParameters().FirstOrDefault(x => !x.IsImplicitlyDeclared), SymbolEqualityComparer.IncludeNullability)))
{
// The case above is basically that if the symbol is a parameter, and the corresponding definition is a property set definition
// AND the first explicitly declared parameter is this symbol, we need to replace it with value.
text = "value";
}
else if (normalizedText.StartsWith("_", StringComparison.OrdinalIgnoreCase) && idSymbol is IFieldSymbol propertyFieldSymbol && propertyFieldSymbol.AssociatedSymbol?.IsKind(SymbolKind.Property) == true)
{
text = propertyFieldSymbol.AssociatedSymbol.Name;
}
else if (normalizedText.EndsWith("Event", StringComparison.OrdinalIgnoreCase) && idSymbol is IFieldSymbol eventFieldSymbol && eventFieldSymbol.AssociatedSymbol?.IsKind(SymbolKind.Event) == true)
{
text = eventFieldSymbol.AssociatedSymbol.Name;
}
else if (WinformsConversions.MayNeedToInlinePropertyAccess(id.Parent, idSymbol) && _typeContext.HandledEventsAnalysis.ShouldGeneratePropertyFor(idSymbol.Name))
{
// For C# Winforms designer, we need to use direct field access - see other usage of MayNeedToInlinePropertyAccess
text = "_" + text;
}
}
private async Task <T> ConvertHandledAsync <T>(VisualBasicSyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CSharpSyntaxNode
{
try {
var converted = (T)await _wrappedVisitor.Visit(vbNode);
return(sourceTriviaMap == SourceTriviaMapKind.None || _syntaxTree != vbNode.SyntaxTree
? converted.WithoutSourceMapping()
: sourceTriviaMap == SourceTriviaMapKind.SubNodesOnly
? converted
: WithSourceMapping(vbNode, converted));
} catch (Exception e) when(_dummyLiteral is T dummy)
{
return(dummy.WithCsTrailingErrorComment(vbNode, e));
} catch (Exception e) when(_dummyStatement is T dummy)
{
return(dummy.WithCsTrailingErrorComment(vbNode, e));
} catch (Exception e) when(_dummyCompilationUnit is T dummy)
{
return(dummy.WithCsTrailingErrorComment(vbNode, e));
} catch (Exception e) when(!(e is ExceptionWithNodeInformation))
{
throw e.WithNodeInformation(vbNode);
}
}
public static async Task <SeparatedSyntaxList <TOut> > AcceptSeparatedListAsync <TIn, TOut>(this SeparatedSyntaxList <TIn> nodes, CommentConvertingVisitorWrapper visitorWrapper, SourceTriviaMapKind sourceTriviaMap = SourceTriviaMapKind.All) where TIn : VisualBasicSyntaxNode where TOut : CSharpSyntaxNode
{
return(await visitorWrapper.Accept <TIn, TOut>(nodes, sourceTriviaMap));
}
public static async Task <TOut> AcceptAsync <TOut>(this SyntaxNode node, CommentConvertingVisitorWrapper visitorWrapper, SourceTriviaMapKind sourceTriviaMap = SourceTriviaMapKind.All) where TOut : CSharpSyntaxNode
{
if (node == null)
{
return(null);
}
return(await visitorWrapper.Accept <TOut>(node, sourceTriviaMap));
}
public static Task <CSharpSyntaxNode> AcceptAsync(this SyntaxNode node, CommentConvertingVisitorWrapper visitorWrapper, SourceTriviaMapKind sourceTriviaMap = SourceTriviaMapKind.All)
{
return(AcceptAsync <CSharpSyntaxNode>(node, visitorWrapper, sourceTriviaMap));
}
public async Task <SeparatedSyntaxList <TOut> > Accept <TIn, TOut>(SeparatedSyntaxList <TIn> vbNodes, SourceTriviaMapKind sourceTriviaMap) where TIn : VBasic.VisualBasicSyntaxNode where TOut : CS.CSharpSyntaxNode
{
var convertedNodes = await vbNodes.SelectAsync(n => ConvertHandled <TOut>(n, sourceTriviaMap));
var convertedSeparators = vbNodes.GetSeparators().Select(s =>
CS.SyntaxFactory.Token(CS.SyntaxKind.CommaToken)
.WithConvertedTrailingTriviaFrom(s, TriviaKinds.FormattingOnly)
.WithSourceMappingFrom(s)
);
return(CS.SyntaxFactory.SeparatedList(convertedNodes, convertedSeparators));
}
public async Task <T> Accept <T>(SyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
{
return(await ConvertHandled <T>(vbNode, sourceTriviaMap));
}
/// <summary>For TOut, specify the most general type acceptable by the calling code (often ExpressionSyntax), this allows error information to be attached to a dummy return node.</summary> public static async Task <TOut> AcceptAsync <TOut>(this VisualBasicSyntaxNode node, CommentConvertingVisitorWrapper visitorWrapper, SourceTriviaMapKind sourceTriviaMap = SourceTriviaMapKind.All) where TOut : CSharpSyntaxNode => node == null ? null : await visitorWrapper.AcceptAsync <TOut>(node, sourceTriviaMap);
public async Task <T> AcceptAsync <T>(VisualBasicSyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CSharpSyntaxNode => await ConvertHandledAsync <T>(vbNode, sourceTriviaMap);
