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;
}
}
