public override VisualBasicSyntaxNode VisitAssignmentExpression(CSS.AssignmentExpressionSyntax node) { var kind = ConvertToken(CS.CSharpExtensions.Kind(node), TokenContext.Local); if (node.Parent is CSS.ExpressionStatementSyntax) { return(SyntaxFactory.AssignmentStatement( kind, (ExpressionSyntax)node.Left.Accept(this), SyntaxFactory.Token(VBUtil.GetBinaryExpressionOperatorTokenKind(kind)), (ExpressionSyntax)node.Right.Accept(this) )); } else { MarkPatchInlineAssignHelper(node); return(SyntaxFactory.InvocationExpression( SyntaxFactory.IdentifierName("__InlineAssignHelper"), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( new ArgumentSyntax[] { SyntaxFactory.SimpleArgument((ExpressionSyntax)node.Left.Accept(this)), SyntaxFactory.SimpleArgument((ExpressionSyntax)node.Right.Accept(this)) } ) ) )); } }
static IfStatementSyntax GenerateInvertedIfStatement(IfStatementSyntax ifStatement) { var condition = VBUtil.InvertCondition(ifStatement.Condition); return(SyntaxFactory.IfStatement(condition) .WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)) .WithAdditionalAnnotations(Formatter.Annotation)); }
public override VisualBasicSyntaxNode VisitBinaryExpression(CSS.BinaryExpressionSyntax node) { var kind = ConvertToken(CS.CSharpExtensions.Kind(node), TokenContext.Local); return(SyntaxFactory.BinaryExpression( kind, (ExpressionSyntax)node.Left.Accept(this), SyntaxFactory.Token(VBUtil.GetBinaryExpressionOperatorTokenKind(kind)), (ExpressionSyntax)node.Right.Accept(this) )); }
public override VisualBasicSyntaxNode VisitPostfixUnaryExpression(CSS.PostfixUnaryExpressionSyntax node) { var kind = ConvertToken(CS.CSharpExtensions.Kind(node), TokenContext.Local); if (node.Parent is CSS.ExpressionStatementSyntax) { return(SyntaxFactory.AssignmentStatement( ConvertToken(CS.CSharpExtensions.Kind(node), TokenContext.Local), (ExpressionSyntax)node.Operand.Accept(this), SyntaxFactory.Token(VBUtil.GetBinaryExpressionOperatorTokenKind(kind)), Literal(1) )); } else { string operatorName, minMax; SyntaxKind op; if (kind == SyntaxKind.AddAssignmentStatement) { operatorName = "Increment"; minMax = "Min"; op = SyntaxKind.SubtractExpression; } else { operatorName = "Decrement"; minMax = "Max"; op = SyntaxKind.AddExpression; } return(SyntaxFactory.InvocationExpression( SyntaxFactory.ParseName("Math." + minMax), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( new ArgumentSyntax[] { SyntaxFactory.SimpleArgument( SyntaxFactory.InvocationExpression( SyntaxFactory.ParseName("System.Threading.Interlocked." + operatorName), SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.SimpleArgument((ExpressionSyntax)node.Operand.Accept(this)) ) ) ) ), SyntaxFactory.SimpleArgument(SyntaxFactory.BinaryExpression(op, (ExpressionSyntax)node.Operand.Accept(this), SyntaxFactory.Token(VBUtil.GetBinaryExpressionOperatorTokenKind(op)), Literal(1))) } ) ) )); } }
public override VB.VisualBasicSyntaxNode VisitPredefinedType(CSS.PredefinedTypeSyntax node) { var Token = VBUtil.ConvertTypesTokenToKind(CS.CSharpExtensions.Kind(node.Keyword), true); var switchExpr = Token.RawKind; switch (switchExpr) { case (int)VB.SyntaxKind.EmptyToken: { return VBFactory.ParseTypeName(node.ToString()); } case (int)VB.SyntaxKind.NothingKeyword: { return global::VisualBasicSyntaxFactory.NothingExpression; } default: { return VBFactory.PredefinedType(Token); } } }
internal static bool GetRelationalExpression(SyntaxNode root, TextSpan span, out ExpressionSyntax expr, out SyntaxToken token) { expr = null; token = default(SyntaxToken); var bOp = root.FindNode(span).SkipArgument() as BinaryExpressionSyntax; if (bOp != null && bOp.OperatorToken.Span.Contains(span) && VBUtil.IsRelationalOperator(bOp.Kind())) { expr = bOp; token = bOp.OperatorToken; return(true); } var uOp = root.FindNode(span).SkipArgument() as UnaryExpressionSyntax; if (uOp != null && uOp.OperatorToken.Span.Contains(span) && uOp.IsKind(SyntaxKind.NotExpression)) { expr = uOp; token = uOp.OperatorToken; return(true); } return(false); }
public AccessorBlockSyntax ConvertAccessor(CSS.AccessorDeclarationSyntax node, out bool isIterator, bool isAutoImplementedProperty = false) { SyntaxKind blockKind; AccessorStatementSyntax stmt; EndBlockStatementSyntax endStmt; SyntaxList <StatementSyntax> body; isIterator = false; var accesorKind = CSharpExtensions.Kind(node); var isIteratorState = new MethodBodyExecutableStatementVisitor(_semanticModel, _nodesVisitor, this); body = ConvertBody(node.Body, node.ExpressionBody, accesorKind == CSSyntaxKind.GetAccessorDeclaration, isIteratorState); isIterator = isIteratorState.IsIterator; var attributes = SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(_nodesVisitor))); var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Local); var parent = (CSS.BasePropertyDeclarationSyntax)node.Parent.Parent; Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax valueParam; switch (accesorKind) { case CSSyntaxKind.GetAccessorDeclaration: blockKind = SyntaxKind.GetAccessorBlock; stmt = SyntaxFactory.GetAccessorStatement(attributes, modifiers, null); endStmt = SyntaxFactory.EndGetStatement(); if (isAutoImplementedProperty) { body = body.Count > 0 ? body : SyntaxFactory.SingletonList((StatementSyntax)SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(GetVbPropertyBackingFieldName(parent)))); } break; case CSSyntaxKind.SetAccessorDeclaration: blockKind = SyntaxKind.SetAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.SetAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndSetStatement(); if (isAutoImplementedProperty) { body = body.Count > 0 ? body : SyntaxFactory.SingletonList((StatementSyntax)SyntaxFactory.AssignmentStatement(SyntaxKind.SimpleAssignmentStatement, SyntaxFactory.IdentifierName(GetVbPropertyBackingFieldName(parent)), SyntaxFactory.Token(VBUtil.GetExpressionOperatorTokenKind(SyntaxKind.SimpleAssignmentStatement)), SyntaxFactory.IdentifierName("value") )); } break; case CSSyntaxKind.AddAccessorDeclaration: blockKind = SyntaxKind.AddHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.AddHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndAddHandlerStatement(); break; case CSSyntaxKind.RemoveAccessorDeclaration: blockKind = SyntaxKind.RemoveHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.RemoveHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndRemoveHandlerStatement(); break; default: throw new NotSupportedException(); } return(SyntaxFactory.AccessorBlock(blockKind, stmt, body, endStmt).WithCsSourceMappingFrom(node)); }
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { var document = context.Document; if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles) { return; } var span = context.Span; if (!span.IsEmpty) { return; } var cancellationToken = context.CancellationToken; if (cancellationToken.IsCancellationRequested) { return; } var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (model.IsFromGeneratedCode(cancellationToken)) { return; } var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false); ExpressionSyntax expr; SyntaxToken token; if (!GetRelationalExpression(root, span, out expr, out token)) { return; } if (expr.IsKind(SyntaxKind.NotExpression)) { context.RegisterRefactoring( CodeActionFactory.Create( span, DiagnosticSeverity.Info, string.Format(GettextCatalog.GetString("Invert '{0}'"), expr), t2 => { var uOp = expr as UnaryExpressionSyntax; var convertedExpr = VBUtil.InvertCondition(uOp.Operand.SkipParens()).WithAdditionalAnnotations(Formatter.Annotation); var newRoot = root.ReplaceNode( expr, VBUtil.InvertCondition(uOp.Operand.SkipParens()).WithAdditionalAnnotations(Formatter.Annotation) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); } else if (expr.Parent is ParenthesizedExpressionSyntax && expr.Parent.Parent is UnaryExpressionSyntax) { var unaryOperatorExpression = expr.Parent.Parent as UnaryExpressionSyntax; if (unaryOperatorExpression.IsKind(SyntaxKind.NotExpression)) { context.RegisterRefactoring( CodeActionFactory.Create( span, DiagnosticSeverity.Info, string.Format(GettextCatalog.GetString("Invert '{0}'"), unaryOperatorExpression), t2 => { //var uOp = expr as PrefixUnaryExpressionSyntax; var newRoot = root.ReplaceNode( unaryOperatorExpression, VBUtil.InvertCondition(expr).WithAdditionalAnnotations(Formatter.Annotation) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); } } else { context.RegisterRefactoring( CodeActionFactory.Create( span, DiagnosticSeverity.Info, string.Format(GettextCatalog.GetString("Invert '{0}'"), expr), t2 => { var newRoot = root.ReplaceNode((SyntaxNode) expr, SyntaxFactory.UnaryExpression( SyntaxKind.NotExpression, SyntaxFactory.Token(SyntaxKind.NotKeyword), SyntaxFactory.ParenthesizedExpression(VBUtil.InvertCondition(expr)) ).WithAdditionalAnnotations(Formatter.Annotation) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); } }
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { var document = context.Document; if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles) { return; } var span = context.Span; if (!span.IsEmpty) { return; } var cancellationToken = context.CancellationToken; if (cancellationToken.IsCancellationRequested) { return; } var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (model.IsFromGeneratedCode(cancellationToken)) { return; } var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false); var complexIfBlock = GetMultiLineIfBlockComplex(root, span); if (complexIfBlock != null) { context.RegisterRefactoring( CodeActionFactory.Create( span, DiagnosticSeverity.Info, invertIfFixMessage, t2 => { var newRoot = root.ReplaceNode( complexIfBlock, GenerateNewScript(complexIfBlock) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); return; } var simpleIfBlock = GetMultiLineIfBlockSimple(root, span); if (simpleIfBlock != null) { context.RegisterRefactoring( CodeActionFactory.Create( span, DiagnosticSeverity.Info, invertIfFixMessage, t2 => { var newRoot = root.ReplaceNode( simpleIfBlock, simpleIfBlock .WithIfStatement(simpleIfBlock.IfStatement.WithCondition(VBUtil.InvertCondition(simpleIfBlock.IfStatement.Condition))) .WithStatements(simpleIfBlock.ElseBlock.Statements) .WithElseBlock(simpleIfBlock.ElseBlock.WithStatements(simpleIfBlock.Statements)) .WithAdditionalAnnotations(Formatter.Annotation) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); return; } var inSubIfBlock = GetMultiLineIfBlockLastInSub(root, span); if (inSubIfBlock != null) { context.RegisterRefactoring( CodeActionFactory.Create( inSubIfBlock.Span, DiagnosticSeverity.Info, invertIfFixMessage, t2 => { var ifStatement = GenerateInvertedIfStatement(inSubIfBlock.IfStatement); var invertedIfBlock = SyntaxFactory.MultiLineIfBlock(ifStatement) .WithStatements(new SyntaxList <StatementSyntax>().Add(SyntaxFactory.ReturnStatement())) .WithLeadingTrivia(inSubIfBlock.GetLeadingTrivia()) .WithTrailingTrivia(inSubIfBlock.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newRoot = root.ReplaceNode( inSubIfBlock, new SyntaxNode[] { invertedIfBlock }.Concat(GetStatements(inSubIfBlock)) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); } var inLoopIfBlock = GetMultiLineIfBlockInLoop(root, span); if (inLoopIfBlock != null) { context.RegisterRefactoring( CodeActionFactory.Create( inLoopIfBlock.Span, DiagnosticSeverity.Info, invertIfFixMessage, t2 => { var ifStatement = GenerateInvertedIfStatement(inLoopIfBlock.IfStatement); var invertedIfBlock = SyntaxFactory.MultiLineIfBlock(ifStatement) .WithStatements(new SyntaxList <StatementSyntax>().Add(GetContinueStatement(inLoopIfBlock.Parent))) .WithLeadingTrivia(inLoopIfBlock.GetLeadingTrivia()) .WithTrailingTrivia(inLoopIfBlock.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newRoot = root.ReplaceNode( inLoopIfBlock, new SyntaxNode[] { invertedIfBlock }.Concat(GetStatements(inLoopIfBlock)) ); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); } ) ); return; } }