public override SyntaxList <StatementSyntax> VisitSelectBlock(VBSyntax.SelectBlockSyntax node) { var expr = (ExpressionSyntax)node.SelectStatement.Expression.Accept(_nodesVisitor); var exprWithoutTrivia = expr.WithoutTrivia().WithoutAnnotations(); var sections = new List <SwitchSectionSyntax>(); foreach (var block in node.CaseBlocks) { var labels = new List <SwitchLabelSyntax>(); foreach (var c in block.CaseStatement.Cases) { if (c is VBSyntax.SimpleCaseClauseSyntax s) { var expressionSyntax = (ExpressionSyntax)s.Value.Accept(_nodesVisitor); SwitchLabelSyntax caseSwitchLabelSyntax = SyntaxFactory.CaseSwitchLabel(expressionSyntax); if (!_semanticModel.GetConstantValue(s.Value).HasValue) { caseSwitchLabelSyntax = WrapInCasePatternSwitchLabelSyntax(expressionSyntax); } labels.Add(caseSwitchLabelSyntax); } else if (c is VBSyntax.ElseCaseClauseSyntax) { labels.Add(SyntaxFactory.DefaultSwitchLabel()); } else if (c is VBSyntax.RelationalCaseClauseSyntax relational) { var operatorKind = VBasic.VisualBasicExtensions.Kind(relational); var cSharpSyntaxNode = SyntaxFactory.BinaryExpression(operatorKind.ConvertToken(TokenContext.Local), exprWithoutTrivia, (ExpressionSyntax)relational.Value.Accept(_nodesVisitor)); labels.Add(WrapInCasePatternSwitchLabelSyntax(cSharpSyntaxNode)); } else if (c is VBSyntax.RangeCaseClauseSyntax range) { var lowerBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, (ExpressionSyntax)range.LowerBound.Accept(_nodesVisitor), exprWithoutTrivia); var upperBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, exprWithoutTrivia, (ExpressionSyntax)range.UpperBound.Accept(_nodesVisitor)); var withinBounds = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalAndExpression, lowerBoundCheck, upperBoundCheck); labels.Add(WrapInCasePatternSwitchLabelSyntax(withinBounds)); } else { throw new NotSupportedException(c.Kind().ToString()); } } var csBlockStatements = block.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)).ToList(); if (csBlockStatements.LastOrDefault() ?.IsKind(SyntaxKind.ReturnStatement) != true) { csBlockStatements.Add(SyntaxFactory.BreakStatement()); } var list = SingleStatement(SyntaxFactory.Block(csBlockStatements)); sections.Add(SyntaxFactory.SwitchSection(SyntaxFactory.List(labels), list)); } var switchStatementSyntax = ValidSyntaxFactory.SwitchStatement(expr, sections); return(SingleStatement(switchStatementSyntax)); }
private ExpressionSyntax AddExplicitConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded) { var vbConvertedType = _semanticModel.GetTypeInfo(vbNode).ConvertedType; switch (conversionKind) { case TypeConversionKind.Unknown: case TypeConversionKind.Identity: return(addParenthesisIfNeeded ? VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(vbNode, csNode) : csNode); case TypeConversionKind.DestructiveCast: case TypeConversionKind.NonDestructiveCast: var typeName = (TypeSyntax)_csSyntaxGenerator.TypeExpression(vbConvertedType); if (csNode is CastExpressionSyntax cast && cast.Type.IsEquivalentTo(typeName)) { return(csNode); } return(ValidSyntaxFactory.CastExpression(typeName, csNode)); case TypeConversionKind.Conversion: return(AddExplicitConvertTo(vbNode, csNode, vbConvertedType)); default: throw new ArgumentOutOfRangeException(); } }
public static ExpressionSyntax VbCoerceToString(ExpressionSyntax csNode, TypeInfo typeInfo) { return(typeInfo.Type.SpecialType switch { SpecialType.System_String => csNode, SpecialType.System_Char => SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(csNode, nameof(ToString))), _ => NewStringFromArg(csNode) });
private async Task <ExpressionSyntax> ConvertToLikeOperatorAsync(VBSyntax.BinaryExpressionSyntax node, KnownMethod member) { var(lhs, rhs) = await AcceptSidesAsync(node); var compareText = ValidSyntaxFactory.MemberAccess("CompareMethod", _visualBasicEqualityComparison.OptionCompareTextCaseInsensitive ? "Text" : "Binary"); _visualBasicEqualityComparison.ExtraUsingDirectives.Add("Microsoft.VisualBasic"); return(member.Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives, lhs, rhs, compareText)); }
public ExpressionSyntax GetFullExpressionForVbObjectComparison(VBSyntax.BinaryExpressionSyntax node, ExpressionSyntax lhs, ExpressionSyntax rhs) { _extraUsingDirectives.Add("Microsoft.VisualBasic.CompilerServices"); var optionCompareTextCaseInsensitive = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(OptionCompareTextCaseInsensitive ? SyntaxKind.TrueKeyword : SyntaxKind.FalseLiteralExpression)); var compareObject = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Operators), nameof(Operators.ConditionalCompareObjectEqual)), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(lhs), SyntaxFactory.Argument(rhs), optionCompareTextCaseInsensitive }))); return(NegateIfNeeded(node, compareObject)); }
public ExpressionSyntax GetFullExpressionForVbObjectComparison(ExpressionSyntax lhs, ExpressionSyntax rhs, bool negate = false) { ExtraUsingDirectives.Add("Microsoft.VisualBasic.CompilerServices"); var optionCompareTextCaseInsensitive = SyntaxFactory.Argument(OptionCompareTextCaseInsensitiveBoolExpression); var compareObject = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Operators), nameof(Operators.ConditionalCompareObjectEqual)), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(lhs), SyntaxFactory.Argument(rhs), optionCompareTextCaseInsensitive }))); return(negate ? (ExpressionSyntax)Negate(compareObject) : compareObject); }
private ExpressionSyntax CreateCast(ExpressionSyntax csNode, ITypeSymbol vbConvertedType) { var typeName = (TypeSyntax)_csSyntaxGenerator.TypeExpression(vbConvertedType); if (csNode is CastExpressionSyntax cast && cast.Type.IsEquivalentTo(typeName)) { return(csNode); } return(ValidSyntaxFactory.CastExpression(typeName, csNode)); }
private ExpressionSyntax AddExplicitConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, ITypeSymbol vbConvertedType, TypeConversionKind conversionKind, bool addParenthesisIfNeeded) { switch (conversionKind) { case TypeConversionKind.Unknown: case TypeConversionKind.Identity: return(addParenthesisIfNeeded ? VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(vbNode, csNode) : csNode); case TypeConversionKind.Implicit: return(ValidSyntaxFactory.CastExpression(_semanticModel.GetCsTypeSyntax(vbConvertedType, vbNode), csNode)); case TypeConversionKind.Explicit: return(AddExplicitConvertTo(vbNode, csNode, vbConvertedType)); default: throw new ArgumentOutOfRangeException(); } }
public (ExpressionSyntax csLeft, ExpressionSyntax csRight) AdjustForVbStringComparison(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, bool leftKnownNotNull, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, bool rightKnownNotNull) { (csLeft, csRight) = VbCoerceToNonNullString(vbLeft, csLeft, lhsTypeInfo, leftKnownNotNull, vbRight, csRight, rhsTypeInfo, rightKnownNotNull); if (OptionCompareTextCaseInsensitive) { ExtraUsingDirectives.Add("System.Globalization"); var compareOptions = SyntaxFactory.Argument(GetCompareTextCaseInsensitiveCompareOptions()); var compareString = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(CultureInfo), nameof(CultureInfo.CurrentCulture), nameof(CultureInfo.CompareInfo), nameof(CompareInfo.Compare)), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(csLeft), SyntaxFactory.Argument(csRight), compareOptions }))); csLeft = compareString; csRight = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)); } return(csLeft, csRight); }
private static BinaryExpressionSyntax GetCompareTextCaseInsensitiveCompareOptions() { return(SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseOrExpression, SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseOrExpression, ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreCase)), ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreKanaType))), ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreWidth)) )); }
public MethodDeclarationSyntax AsInstanceMethod(string functionName) => ValidSyntaxFactory.CreateParameterlessMethod(functionName, _returnType, _block);