public (ExpressionSyntax Expr, bool IsCorrectType) GetConstantOrNull(VBSyntax.ExpressionSyntax vbNode, ITypeSymbol type, TypeConversionAnalyzer.TypeConversionKind analyzedConversionKind, ExpressionSyntax csNode)
{
var vbOperation = _semanticModel.GetOperation(vbNode).SkipParens(true);
// Guideline tradeoff: Usually would aim for erring on the side of correct runtime behaviour. But making lots of simple constants unreadable for the sake of an edge case that will turn into an easily fixed compile error seems overkill.
// See https://github.com/icsharpcode/CodeConverter/blob/master/.github/CONTRIBUTING.md#deciding-what-the-output-should-be
bool isExactType = analyzedConversionKind == TypeConversionAnalyzer.TypeConversionKind.Identity;
if ((isExactType || analyzedConversionKind == TypeConversionAnalyzer.TypeConversionKind.NonDestructiveCast) &&
IsProbablyConstExpression(vbOperation))
{
return(csNode, isExactType);
}
if (TryCompileTimeEvaluate(vbOperation, out var result))
{
if (type.Name == "Char" && result is int resultInt)
{
result = Strings.ChrW(resultInt);
}
else if (ConversionsTypeFullNames.TryGetValue(type.GetFullMetadataName(), out var method))
{
result = method.Invoke(null, new[] { result });
}
return(LiteralConversions.GetLiteralExpression(result, convertedType: type), true);
}
return(null, false);
}
public (ExpressionSyntax lhs, ExpressionSyntax rhs) VbCoerceToNonNullString(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, bool leftKnownNotNull, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, bool rightKnownNotNull)
{
if (IsNonEmptyStringLiteral(vbLeft) || IsNonEmptyStringLiteral(vbRight))
{
// If one of the strings is "foo", the other string won't equal it if it's null or empty, so it doesn't matter which one we use in comparison
return(csLeft, csRight);
}
return(VbCoerceToNonNullString(vbLeft, csLeft, lhsTypeInfo, leftKnownNotNull), VbCoerceToNonNullString(vbRight, csRight, rhsTypeInfo, rightKnownNotNull));
}
public static bool AlwaysHasBooleanTypeInCSharp(this VBSyntax.ExpressionSyntax vbNode)
{
var parent = vbNode.SkipOutOfParens()?.Parent;
return(parent is VBSyntax.SingleLineIfStatementSyntax singleLine && singleLine.Condition == vbNode ||
parent is VBSyntax.IfStatementSyntax ifStatement && ifStatement.Condition == vbNode ||
parent is VBSyntax.ElseIfStatementSyntax elseIfStatement && elseIfStatement.Condition == vbNode ||
parent is VBSyntax.TernaryConditionalExpressionSyntax ternary && ternary.Condition == vbNode ||
parent is VBSyntax.BinaryConditionalExpressionSyntax binary && binary.FirstExpression == vbNode);
}
public static VBSyntax.ExpressionSyntax SkipOutOfParens(this VBSyntax.ExpressionSyntax expression)
{
if (expression == null)
{
return(null);
}
while (expression is VBSyntax.ParenthesizedExpressionSyntax pes)
{
expression = pes.Parent as VBSyntax.ExpressionSyntax;
}
return(expression);
}
public ExpressionSyntax VbCoerceToNonNullString(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeInfo typeInfo, bool knownNotNull = false)
{
if (IsNothingOrEmpty(vbNode))
{
return(EmptyStringExpression());
}
if (knownNotNull || !CanBeNull(vbNode))
{
return(csNode);
}
csNode = typeInfo.Type?.SpecialType == SpecialType.System_String
? Coalesce(csNode, EmptyStringExpression()).AddParens()
: Coalesce(csNode, EmptyCharArrayExpression());
return(VbCoerceToString(csNode, typeInfo));
}
private static bool IsNonEmptyStringLiteral(VBSyntax.ExpressionSyntax vbExpr)
{
vbExpr = vbExpr.SkipIntoParens();
return(vbExpr.IsKind(VBSyntaxKind.StringLiteralExpression) && vbExpr is VBSyntax.LiteralExpressionSyntax literal && !IsEmptyString(literal));
}
/// <summary>
/// Returns true only if expression is static (i.e. doesn't reference the containing instance)
/// </summary>
private static bool IsDefinitelyStatic(this SemanticModel semanticModel, VBSyntax.ExpressionSyntax e)
{
return(semanticModel.GetOperation(e).DescendantsAndSelf().OfType <IInstanceReferenceOperation>().Any() == false);
}
/// <summary>
/// Returns true only if expressions static (i.e. doesn't reference the containing instance)
/// </summary>
public static bool IsDefinitelyStatic(this SemanticModel semanticModel, VBSyntax.ModifiedIdentifierSyntax vbName, VBSyntax.ExpressionSyntax vbInitValue)
{
var arrayBoundExpressions = vbName.ArrayBounds != null?vbName.ArrayBounds.Arguments.Select(a => a.GetExpression()) : Enumerable.Empty <VBSyntax.ExpressionSyntax>();
var expressions = vbInitValue.Yield().Concat(arrayBoundExpressions).Where(x => x != null).ToArray();
return(expressions.All(e => semanticModel.IsDefinitelyStatic(e)));
}
/// <summary>
/// This is a conversion heavily based on Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax.SyntaxExtensions.ExtractAnonymousTypeMemberName from 1bbbfc28a8e4493b4057e171310343a4c7ba826c
/// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0
/// </summary>
public static SyntaxToken?ExtractAnonymousTypeMemberName(this VBSyntax.ExpressionSyntax input)
{
Stack <VBSyntax.ConditionalAccessExpressionSyntax> conditionalAccessStack = null;
while (true)
{
switch (input.Kind())
{
case VBasic.SyntaxKind.IdentifierName: {
return(((VBSyntax.IdentifierNameSyntax)input).Identifier);
}
case VBasic.SyntaxKind.XmlName: {
var xmlNameInferredFrom = (VBSyntax.XmlNameSyntax)input;
var name = xmlNameInferredFrom.LocalName;
// CONVERSION NOTE: Slightly skimped on the details here for brevity
return(VBasic.SyntaxFacts.IsValidIdentifier(name.ToString()) ? name : default(SyntaxToken?));
}
case VBasic.SyntaxKind.XmlBracketedName: {
// handles something like <a-a>
var xmlNameInferredFrom = (VBSyntax.XmlBracketedNameSyntax)input;
input = xmlNameInferredFrom.Name;
continue;
}
case VBasic.SyntaxKind.SimpleMemberAccessExpression:
case VBasic.SyntaxKind.DictionaryAccessExpression: {
var memberAccess = (VBSyntax.MemberAccessExpressionSyntax)input;
var receiver = memberAccess.Expression ?? conditionalAccessStack.Pop();
if (input.Kind() == VBasic.SyntaxKind.SimpleMemberAccessExpression)
{
// See if this is an identifier qualified with XmlElementAccessExpression or XmlDescendantAccessExpression
if (receiver != null)
{
switch (receiver.Kind())
{
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
input = receiver;
continue;
}
}
}
}
conditionalAccessStack = null;
input = memberAccess.Name;
continue;
}
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlAttributeAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
var xmlAccess = (VBSyntax.XmlMemberAccessExpressionSyntax)input;
conditionalAccessStack.Clear();
input = xmlAccess.Name;
continue;
}
case VBasic.SyntaxKind.InvocationExpression: {
var invocation = (VBSyntax.InvocationExpressionSyntax)input;
var target = invocation.Expression ?? conditionalAccessStack.Pop();
if (target == null)
{
break;
}
if (invocation.ArgumentList == null || invocation.ArgumentList.Arguments.Count == 0)
{
input = target;
continue;
}
if (invocation.ArgumentList.Arguments.Count == 1)
{
// See if this is an indexed XmlElementAccessExpression or XmlDescendantAccessExpression
switch (target.Kind())
{
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
input = target;
continue;
}
}
}
break;
}
case VBasic.SyntaxKind.ConditionalAccessExpression: {
var access = (VBSyntax.ConditionalAccessExpressionSyntax)input;
if (conditionalAccessStack == null)
{
conditionalAccessStack = new Stack <VBSyntax.ConditionalAccessExpressionSyntax>();
}
conditionalAccessStack.Push(access);
input = access.WhenNotNull;
continue;
}
}
return(null);
}
}
internal SyntaxTrivia ConvertTrivia(SyntaxTrivia t)
{
var switchExpr = t.RawKind;
/* TODO ERROR: Skipped RegionDirectiveTrivia */
switch (switchExpr)
{
case (int)CS.SyntaxKind.WhitespaceTrivia: {
return(VBFactory.WhitespaceTrivia(t.ToString()));
}
case (int)CS.SyntaxKind.EndOfLineTrivia: {
return(VisualBasicSyntaxFactory.VBEOLTrivia);
}
case (int)CS.SyntaxKind.SingleLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/", StringComparison.InvariantCulture))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4))}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2))}"));
}
case (int)CS.SyntaxKind.MultiLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/", StringComparison.InvariantCulture))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
case (int)CS.SyntaxKind.DocumentationCommentExteriorTrivia: {
return(VBFactory.SyntaxTrivia(VBasic.SyntaxKind.CommentTrivia, "'''"));
}
case (int)CS.SyntaxKind.DisabledTextTrivia: {
if (TriviaDepth > 0)
{
return(VBFactory.DisabledTextTrivia(t.ToString().WithoutNewLines(' ')));
}
return(VBFactory.DisabledTextTrivia(t.ToString().ConsistentNewlines()));
}
case (int)CS.SyntaxKind.PreprocessingMessageTrivia: {
return(VBFactory.CommentTrivia($" ' {t}"));
}
case (int)CS.SyntaxKind.None: {
return(default(SyntaxTrivia));
}
}
/* TODO ERROR: Skipped EndRegionDirectiveTrivia */
/* TODO ERROR: Skipped RegionDirectiveTrivia */
CSSyntax.StructuredTriviaSyntax StructuredTrivia = (CSSyntax.StructuredTriviaSyntax)t.GetStructure();
Debug.Assert(StructuredTrivia != null, $"Found new type of non structured trivia {t.RawKind}");
var switchExpr1 = t.RawKind;
switch (switchExpr1)
{
case (int)CS.SyntaxKind.DefineDirectiveTrivia: {
CSSyntax.DefineDirectiveTriviaSyntax DefineDirective = (CSSyntax.DefineDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(DefineDirective.Name.ValueText);
VBSyntax.ExpressionSyntax value = VBFactory.TrueLiteralExpression(VisualBasicSyntaxFactory.TrueKeyword);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), DefineDirective), DefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.UndefDirectiveTrivia: {
CSSyntax.UndefDirectiveTriviaSyntax UndefineDirective = (CSSyntax.UndefDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(UndefineDirective.Name.ValueText);
VBSyntax.ExpressionSyntax value = VisualBasicSyntaxFactory.NothingExpression;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), UndefineDirective), UndefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.EndIfDirectiveTrivia: {
if (TriviaDepth > 0)
{
TriviaDepth -= 1;
return(VBFactory.CommentTrivia($"' TODO VB does not allow directives here, original statement {t.ToFullString().WithoutNewLines(' ')}"));
}
CSSyntax.EndIfDirectiveTriviaSyntax EndIfDirective = (CSSyntax.EndIfDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndIfDirectiveTrivia().WithConvertedTrailingTriviaFrom(EndIfDirective.EndIfKeyword), EndIfDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.ErrorDirectiveTrivia: {
CSSyntax.ErrorDirectiveTriviaSyntax ErrorDirective = (CSSyntax.ErrorDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Error Directive Trivia, Original Directive {ErrorDirective.ToFullString()}"));
}
case (int)CS.SyntaxKind.IfDirectiveTrivia: {
if (t.Token.Parent?.AncestorsAndSelf().OfType <CSSyntax.InitializerExpressionSyntax>().Any() == true)
{
TriviaDepth += 1;
}
CSSyntax.IfDirectiveTriviaSyntax IfDirective = (CSSyntax.IfDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(IfDirective.Condition.ToString());
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.IfDirectiveTrivia(VisualBasicSyntaxFactory.IfKeyword, VBFactory.ParseExpression(Expression1)).With(IfDirective.GetLeadingTrivia().ConvertTrivia(), IfDirective.Condition.GetTrailingTrivia().ConvertTrivia()), IfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.ElifDirectiveTrivia: {
if (t.Token.Parent.AncestorsAndSelf().OfType <CSSyntax.InitializerExpressionSyntax>().Any())
{
TriviaDepth += 1;
}
CSSyntax.ElifDirectiveTriviaSyntax ELIfDirective = (CSSyntax.ElifDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(ELIfDirective.Condition.ToString());
SyntaxToken IfOrElseIfKeyword;
if (t.IsKind(CS.SyntaxKind.ElifDirectiveTrivia))
{
IfOrElseIfKeyword = VisualBasicSyntaxFactory.ElseIfKeyword;
}
else
{
IfOrElseIfKeyword = VisualBasicSyntaxFactory.IfKeyword;
}
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.ElseIfDirectiveTrivia(IfOrElseIfKeyword, VBFactory.ParseExpression(Expression1))
.With(ELIfDirective.GetLeadingTrivia().ConvertTrivia(), ELIfDirective.Condition.GetTrailingTrivia().ConvertTrivia())
, ELIfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.LineDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Line Directive Trivia, Original Directive {t}"));
}
case (int)CS.SyntaxKind.ElseDirectiveTrivia: {
return(VBFactory.Trivia(WithTrailingEOL(VBFactory.ElseDirectiveTrivia().NormalizeWhitespace().WithConvertedTrailingTriviaFrom(((CSSyntax.ElseDirectiveTriviaSyntax)StructuredTrivia).ElseKeyword))));
}
case (int)CS.SyntaxKind.EndRegionDirectiveTrivia: {
CSSyntax.EndRegionDirectiveTriviaSyntax EndRegionDirective = (CSSyntax.EndRegionDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndRegionDirectiveTrivia(VisualBasicSyntaxFactory.HashToken, VisualBasicSyntaxFactory.EndKeyword, VisualBasicSyntaxFactory.RegionKeyword), EndRegionDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.PragmaWarningDirectiveTrivia: {
// Dim PragmaWarningDirectiveTrivia As CSSyntax.PragmaWarningDirectiveTriviaSyntax = DirectCast(StructuredTrivia, CSSyntax.PragmaWarningDirectiveTriviaSyntax)
// Dim ErrorList As New List(Of VBS.IdentifierNameSyntax)
// Dim TrailingTriviaStringBuilder As New StringBuilder
// For Each i As CSSyntax.ExpressionSyntax In PragmaWarningDirectiveTrivia.ErrorCodes
// Dim ErrorCode As String = i.ToString
// If ErrorCode.IsInteger Then
// ErrorCode = $"CS_{ErrorCode}"
// End If
// ErrorList.Add(VBFactory.IdentifierName(ErrorCode))
// For Each Trivial As SyntaxTrivia In i.GetTrailingTrivia
// TrailingTriviaStringBuilder.Append(Trivial.ToString)
// Next
// Next
// Dim WarningDirectiveTrivia As VBS.DirectiveTriviaSyntax
// If PragmaWarningDirectiveTrivia.DisableOrRestoreKeyword.IsKind(CS.SyntaxKind.DisableKeyword) Then
// WarningDirectiveTrivia = VBFactory.DisableWarningDirectiveTrivia(ErrorList.ToArray)
// Else
// WarningDirectiveTrivia = VBFactory.EnableWarningDirectiveTrivia(ErrorList.ToArray)
// End If
// Return VBFactory.CommentTrivia($" ' TODO {WarningDirectiveTrivia.NormalizeWhitespace}{TrailingTriviaStringBuilder.ToString}")
return(default(SyntaxTrivia));
}
case (int)CS.SyntaxKind.RegionDirectiveTrivia: {
CSSyntax.RegionDirectiveTriviaSyntax RegionDirective = (CSSyntax.RegionDirectiveTriviaSyntax)StructuredTrivia;
var EndOfDirectiveToken = RegionDirective.EndOfDirectiveToken;
string NameString = $"\"{EndOfDirectiveToken.LeadingTrivia.ToString().Replace("\"", "")}\"";
var RegionDirectiveTriviaNode = VBFactory.RegionDirectiveTrivia(VisualBasicSyntaxFactory.HashToken, VisualBasicSyntaxFactory.RegionKeyword, VBFactory.StringLiteralToken(NameString, NameString)
).WithConvertedTrailingTriviaFrom(EndOfDirectiveToken);
return(VBFactory.Trivia(WithTrailingEOL(RegionDirectiveTriviaNode)));
}
case (int)CS.SyntaxKind.SingleLineDocumentationCommentTrivia: {
CSSyntax.DocumentationCommentTriviaSyntax SingleLineDocumentationComment = (CSSyntax.DocumentationCommentTriviaSyntax)StructuredTrivia;
var walker = new XMLVisitor();
walker.Visit(SingleLineDocumentationComment);
var xmlNodes = new List <VBSyntax.XmlNodeSyntax>();
for (int i = 0, loopTo = SingleLineDocumentationComment.Content.Count - 1; i <= loopTo; i++)
{
var node = SingleLineDocumentationComment.Content[i];
if (!node.IsKind(CS.SyntaxKind.XmlText) && node.GetLeadingTrivia().Count > 0 && node.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
if (i < SingleLineDocumentationComment.Content.Count - 1)
{
var NextNode = SingleLineDocumentationComment.Content[i + 1];
if (!NextNode.IsKind(CS.SyntaxKind.XmlText) || NextNode.GetLeadingTrivia().Count == 0 || !NextNode.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
xmlNodes.Add(VBFactory.XmlText(" ").WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("'''")));
}
}
node = node.WithoutLeadingTrivia();
}
VBSyntax.XmlNodeSyntax Item = (VBSyntax.XmlNodeSyntax)node.Accept(walker);
xmlNodes.Add(Item);
}
var DocumentationCommentTrivia = VBFactory.DocumentationCommentTrivia(VBFactory.List(xmlNodes.ToArray()));
if (!DocumentationCommentTrivia.HasLeadingTrivia || !DocumentationCommentTrivia.GetLeadingTrivia()[0].IsKind(VBasic.SyntaxKind.DocumentationCommentExteriorTrivia))
{
DocumentationCommentTrivia = DocumentationCommentTrivia.WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("''' "));
}
var _DocumentationComment = VBFactory.Trivia(DocumentationCommentTrivia.WithTrailingTrivia(VBFactory.EndOfLine("")));
return(_DocumentationComment);
}
case (int)CS.SyntaxKind.PragmaChecksumDirectiveTrivia: {
CSSyntax.PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirective = (CSSyntax.PragmaChecksumDirectiveTriviaSyntax)StructuredTrivia;
var Guid1 = VBFactory.ParseToken(PragmaChecksumDirective.Guid.Text.ToUpperInvariant());
var Bytes = VBFactory.ParseToken(PragmaChecksumDirective.Bytes.Text);
var ExternalSource = VBFactory.ParseToken(PragmaChecksumDirective.File.Text);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(
VBFactory.ExternalChecksumDirectiveTrivia(VisualBasicSyntaxFactory.HashToken, VisualBasicSyntaxFactory.ExternalChecksumKeyword, VisualBasicSyntaxFactory.OpenParenToken, ExternalSource, VisualBasicSyntaxFactory.CommaToken, Guid1, VisualBasicSyntaxFactory.CommaToken, Bytes, VisualBasicSyntaxFactory.CloseParenToken), PragmaChecksumDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.SkippedTokensTrivia: {
var Builder = new StringBuilder();
foreach (SyntaxToken tok in ((CSSyntax.SkippedTokensTriviaSyntax)StructuredTrivia).Tokens)
{
Builder.Append(tok.ToString());
}
return(VBFactory.CommentTrivia($"' TODO: Error SkippedTokensTrivia '{Builder}'"));
}
case (int)CS.SyntaxKind.BadDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Skipped BadDirectiveTrivia"));
}
case (int)CS.SyntaxKind.ConflictMarkerTrivia: {
break;
}
case (int)CS.SyntaxKind.LoadDirectiveTrivia: {
break;
}
default: {
Debug.WriteLine(((VBasic.SyntaxKind)Conversions.ToUShort(t.RawKind)).ToString());
break;
}
}
throw new NotImplementedException($"t.Kind({(VBasic.SyntaxKind)Conversions.ToUShort(t.RawKind)}) Is unknown");
}
private async Task <ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg) => await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg) ?? await binaryExpressionArg.AcceptAsync <ExpressionSyntax>(_triviaConvertingVisitor);
public async Task <ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsync(VBSyntax.ExpressionSyntax exprNode, bool negateExpression = false)
{
if (!(exprNode is VBSyntax.BinaryExpressionSyntax node) ||
!node.IsKind(VBasic.SyntaxKind.IsExpression, VBasic.SyntaxKind.EqualsExpression, VBasic.SyntaxKind.IsNotExpression, VBasic.SyntaxKind.NotEqualsExpression))
{
return(null);
}
var notted =
node.IsKind(VBasic.SyntaxKind.IsNotExpression, VBasic.SyntaxKind.NotEqualsExpression) ||
negateExpression;
var isReferenceComparison = node.IsKind(VBasic.SyntaxKind.IsExpression, VBasic.SyntaxKind.IsNotExpression);
if (ArgComparedToNull(node) is {} vbOtherArg)
{
var csOtherArg = await ConvertIsOrIsNotExpressionArgAsync(vbOtherArg);
return(notted
? CommonConversions.NotNothingComparison(csOtherArg, isReferenceComparison)
: CommonConversions.NothingComparison(csOtherArg, isReferenceComparison));
}
if (isReferenceComparison)
{
var lhs = await ConvertIsOrIsNotExpressionArgAsync(node.Left);
var rhs = await ConvertIsOrIsNotExpressionArgAsync(node.Right);
var equalityCheck = new KnownMethod(nameof(System), nameof(Object), nameof(object.ReferenceEquals))
.Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives,
ConvertTo(node.Left, lhs, SpecialType.System_Object), rhs);
return(notted
? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, equalityCheck)
: equalityCheck);
}
return(null);
}
private ExpressionSyntax ConvertTo(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, SpecialType targetType)
{
return(_typeConversionAnalyzer.AddExplicitConversion(vbNode, csNode, forceTargetType: _semanticModel.Compilation.GetSpecialType(targetType)));
}
