public void GetInheritedPanelObjectFromFieldExpression()
{
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression("self.panel1.Name = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(assignment.Left as AttributeAccess);
Assert.AreEqual(DerivedForm.GetPanel(), field.GetObject(ComponentCreator));
}
private static ImmutableArray <IfRefactoring> Analyze(
ExpressionStatementSyntax expressionStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
SimpleAssignmentExpression assignment;
if (SimpleAssignmentExpression.TryCreate(expressionStatement, out assignment))
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentExpression assignment1;
if (SimpleAssignmentExpression.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentExpression assignment2;
if (SimpleAssignmentExpression.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsEquivalentTo(assignment2.Left, topLevel: false) &&
assignment1.Left.IsEquivalentTo(assignment.Left, topLevel: false) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(expressionStatement.SpanStart, ifStatement.Span.End)))
{
return(new AssignmentAndIfElseToAssignmentWithConditionalExpression(expressionStatement, assignment.Right, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public void LocalVariableIsNotSelfReference()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("listViewItem1.TooltipText = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.IsFalse(field.IsSelfReference);
}
public void PrivateClassVariableIsSelfReference()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("@listView1.TooltipText = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.IsTrue(field.IsSelfReference);
}
public void NullPassedToRubyControlFieldExpressionEquals()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("self.textBox1.Name = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.IsFalse(field.Equals(null));
}
protected override bool IsFixableStatement(
StatementSyntax statement,
string name,
ITypeSymbol typeSymbol,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (statement.SpanOrLeadingTriviaContainsDirectives())
{
return(false);
}
if (!(statement is ExpressionStatementSyntax expressionStatement))
{
return(false);
}
if (!SimpleAssignmentExpression.TryCreate(expressionStatement.Expression, out SimpleAssignmentExpression simpleAssignment))
{
return(false);
}
if (name != (simpleAssignment.Left as IdentifierNameSyntax)?.Identifier.ValueText)
{
return(false);
}
if (!MemberInvocationExpression.TryCreate(simpleAssignment.Right, out MemberInvocationExpression memberInvocation))
{
return(false);
}
if (!(WalkDownMethodChain(memberInvocation).Expression is IdentifierNameSyntax identifierName))
{
return(false);
}
if (name != identifierName.Identifier.ValueText)
{
return(false);
}
if (!semanticModel.TryGetMethodInfo(memberInvocation.InvocationExpression, out MethodInfo methodInfo, cancellationToken))
{
return(false);
}
if (!methodInfo.ReturnType.Equals(typeSymbol))
{
return(false);
}
if (IsReferenced(memberInvocation.InvocationExpression, identifierName, name, semanticModel, cancellationToken))
{
return(false);
}
return(true);
}
public void GetMemberNamesForButtonPropertyReference()
{
string[] expected = new string[] { "@button1", "Location" };
string code = "@button1.Location = System::Drawing::Point.new(0, 0)";
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(code);
Assert.AreEqual(expected, RubyControlFieldExpression.GetMemberNames(assignment.Left as AttributeAccess));
}
public void GetMemberNamesForFormClientSizePropertyReference()
{
string[] expected = new string[] { "self", "ClientSize" };
string code = "self.ClientSize = System::Drawing::Size.new(300, 400)";
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(code);
Assert.AreEqual(expected, RubyControlFieldExpression.GetMemberNames(assignment.Left as AttributeAccess));
}
public void GetMemberNamesForColorReference()
{
string[] expected = new string[] { "System", "Drawing", "Color", "Red" };
string code = "self.BackColor = System::Drawing::Color.Red";
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(code);
Assert.AreEqual(expected, RubyControlFieldExpression.GetMemberNames(assignment.Right as MethodCall));
}
public void GetMemberNames()
{
string[] expected = new string[] { "a", "b" };
string code = "a.b = 0";
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(code);
Assert.AreEqual(expected, RubyControlFieldExpression.GetMemberNames(assignment.Left as AttributeAccess));
}
public void GetInvalidTwoLevelDeepButtonPropertyDescriptorForSelfReference()
{
using (Button button = new Button()) {
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("self.button1.InvalidProperty.BorderSize = 3");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.IsNull(field.GetObjectForMemberName(button));
}
}
public void GetButtonFlatAppearanceObject()
{
using (Button button = new Button()) {
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("@button1.FlatAppearance.BorderSize = 3");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.AreEqual(button.FlatAppearance, field.GetObjectForMemberName(button));
}
}
public void GetButtonObject()
{
using (Button button = new Button()) {
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("@button1.Size = System::Drawing::Size.new(10, 10)");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.AreEqual(button, field.GetObjectForMemberName(button));
}
}
public void LocalVariableCreatingNewInstance()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("listViewItem1 = System::Windows::Forms.ListViewItem.new()");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as LocalVariable);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression(String.Empty, "listViewItem1", String.Empty, "listViewItem1");
Assert.AreEqual(expectedField, field);
}
public void LocalVariableInAssignment()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("listViewItem1.TooltipText = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression("TooltipText", "listViewItem1", String.Empty, "listViewItem1.TooltipText");
Assert.AreEqual(expectedField, field);
}
public void RubyControlFieldExpressionEquals()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("self.textBox1.Name = \"abc\"");
RubyControlFieldExpression field1 = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
expression = RubyParserHelper.GetSimpleAssignmentExpression("self.textBox1.Name = \"def\"");
RubyControlFieldExpression field2 = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
Assert.AreEqual(field1, field2);
}
public static void Analyze(SyntaxNodeAnalysisContext context, LocalDeclarationStatementSyntax localDeclaration)
{
if (!localDeclaration.IsConst &&
!localDeclaration.SpanOrTrailingTriviaContainsDirectives())
{
VariableDeclarationSyntax declaration = localDeclaration.Declaration;
if (declaration != null)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
if (variables.Any())
{
StatementSyntax nextStatement = localDeclaration.NextStatement();
if (nextStatement?.SpanOrLeadingTriviaContainsDirectives() == false)
{
SimpleAssignmentExpression assignment;
if (SimpleAssignmentExpression.TryCreate(nextStatement, out assignment) &&
assignment.Left.IsKind(SyntaxKind.IdentifierName))
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
VariableDeclaratorSyntax declarator = FindInitializedVariable((IdentifierNameSyntax)assignment.Left, variables, semanticModel, cancellationToken);
if (declarator != null)
{
EqualsValueClauseSyntax initializer = declarator.Initializer;
ExpressionSyntax value = initializer?.Value;
if (value == null ||
IsDefaultValue(declaration.Type, value, semanticModel, cancellationToken))
{
context.ReportDiagnostic(DiagnosticDescriptors.MergeLocalDeclarationWithAssignment, declarator.Identifier);
if (value != null)
{
context.ReportNode(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, initializer);
context.ReportToken(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, assignment.Expression.OperatorToken);
}
context.ReportToken(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, localDeclaration.SemicolonToken);
context.ReportNode(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, assignment.Left);
}
}
}
}
}
}
}
}
public void SetUpFixture()
{
componentCreator = new MockComponentCreator();
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(GetRubyCode());
rhsAssignmentExpression = assignment.Right;
mockDesignerLoaderHost = new MockDesignerLoaderHost();
typeResolutionService = mockDesignerLoaderHost.TypeResolutionService;
RubyCodeDeserializer deserializer = new RubyCodeDeserializer(componentCreator);
deserializedObject = deserializer.Deserialize(rhsAssignmentExpression);
}
public void EnumReturnedInArgumentsPassedToConstructor()
{
string rubyCode = "self.Font = System::Drawing::Font.new(\"Times New Roman\", System::Drawing::FontStyle.Regular, System::Drawing::GraphicsUnit.Point)";
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(rubyCode);
List <object> expectedArgs = new List <object>();
expectedArgs.Add("Times New Roman");
expectedArgs.Add(FontStyle.Regular);
expectedArgs.Add(GraphicsUnit.Point);
List <object> args = deserializer.GetArguments(assignment.Right as MethodCall);
Assert.AreEqual(expectedArgs, args);
}
public static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
if (ifStatement.IsSimpleIf() &&
!IsPartOfLazyInitialization(ifStatement))
{
EqualsToNullExpression equalsToNull;
if (EqualsToNullExpression.TryCreate(ifStatement.Condition, out equalsToNull))
{
SimpleAssignmentExpression assignment;
if (SimpleAssignmentExpression.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment) &&
assignment.Left.IsEquivalentTo(equalsToNull.Left, topLevel: false) &&
assignment.Right.IsSingleLine() &&
!ifStatement.SpanContainsDirectives())
{
StatementSyntax fixableStatement = ifStatement;
SyntaxList <StatementSyntax> statements;
if (ifStatement.TryGetContainingList(out statements))
{
int index = statements.IndexOf(ifStatement);
if (index > 0)
{
StatementSyntax previousStatement = statements[index - 1];
if (CanRefactor(previousStatement, ifStatement, equalsToNull.Left, ifStatement.Parent))
{
fixableStatement = previousStatement;
}
}
}
context.ReportDiagnostic(DiagnosticDescriptors.UseCoalesceExpression, fixableStatement);
}
}
}
}
void WalkSimpleAssignment(SimpleAssignmentExpression node)
{
AttributeAccess attributeAccess = node.Left as AttributeAccess;
InstanceVariable instance = node.Left as InstanceVariable;
LocalVariable localVariable = node.Left as LocalVariable;
if (attributeAccess != null)
{
RubyControlFieldExpression field = RubyControlFieldExpression.Create(attributeAccess);
object propertyValue = deserializer.Deserialize(node.Right);
if (propertyValue != null)
{
field.SetPropertyValue(componentCreator, propertyValue);
}
else if (IsResource(node.Right))
{
field.SetPropertyValue(componentCreator, GetResource(node.Right as MethodCall));
}
else
{
ThrowCouldNotFindTypeException(node.Right);
}
}
else if (instance != null)
{
string instanceName = RubyControlFieldExpression.GetVariableName(instance.Name);
object propertyValue = deserializer.Deserialize(instanceName, node.Right);
AddComponent(instanceName, propertyValue);
}
else if (localVariable != null)
{
object propertyValue = deserializer.Deserialize(localVariable.Name, node.Right);
if (propertyValue == null)
{
ThrowCouldNotFindTypeException(node.Right);
}
}
}
private static ImmutableArray <IfRefactoring> Analyze(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
VariableDeclaratorSyntax declarator = localDeclarationStatement.Declaration?.SingleVariableOrDefault();
if (declarator != null)
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentExpression assignment1;
if (SimpleAssignmentExpression.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentExpression assignment2;
if (SimpleAssignmentExpression.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsKind(SyntaxKind.IdentifierName) &&
assignment2.Left.IsKind(SyntaxKind.IdentifierName))
{
string identifier1 = ((IdentifierNameSyntax)assignment1.Left).Identifier.ValueText;
string identifier2 = ((IdentifierNameSyntax)assignment2.Left).Identifier.ValueText;
if (string.Equals(identifier1, identifier2, StringComparison.Ordinal) &&
string.Equals(identifier1, declarator.Identifier.ValueText, StringComparison.Ordinal) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(localDeclarationStatement.SpanStart, ifStatement.Span.End)))
{
return(new LocalDeclarationAndIfElseAssignmentWithConditionalExpression(localDeclarationStatement, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit)
{
var expression = new SimpleAssignmentExpression(target, value, semanticModel, syntax, target.Type, default(Optional <object>), isImplicit);
return(new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional <object>), isImplicit: isImplicit));
}
