public Statement GetStatement()
{
var whenNotNull = statementInterpreterHandler.GetStatement(conditionalAccessExpressionSyntax.WhenNotNull);
var condition = new BinaryStatement
{
Left = statementInterpreterHandler.GetStatement(conditionalAccessExpressionSyntax.Expression),
Right = new ConstantStatement(null),
Operand = BinaryOperand.NotEqual
};
//IsAssignment
var parent = GetParent(conditionalAccessExpressionSyntax);
if (parent is ArgumentSyntax ||
parent is EqualsValueClauseSyntax)
{
return(new ConditionalStatement
{
Condition = condition,
IfTrue = whenNotNull,
IfFalse = new ConstantStatement(null)
});
}
return(new IfStatement
{
Condition = condition,
IfTrue = whenNotNull
});
}
public Statement GetStatement()
{
if (binaryExpressionSyntax.Kind() == SyntaxKind.IsExpression)
{
var statement = statementInterpreterHandler.GetStatement(binaryExpressionSyntax.Left);
var typeSymbol = (INamedTypeSymbol)semanticModel.GetSymbolInfo(binaryExpressionSyntax.Right).Symbol;
return(new IsTypeStatement
{
Statement = statement,
Type = typeSymbol.GetClassType()
});
}
else if (binaryExpressionSyntax.Kind() == SyntaxKind.AsExpression)
{
var statement = statementInterpreterHandler.GetStatement(binaryExpressionSyntax.Left);
var typeSymbol = (INamedTypeSymbol)semanticModel.GetSymbolInfo(binaryExpressionSyntax.Right).Symbol;
return(new AsStatement
{
Statement = statement,
Type = typeSymbol.GetClassType()
});
}
var binaryStatement = new BinaryStatement();
binaryStatement.Left = statementInterpreterHandler.GetStatement(binaryExpressionSyntax.Left);
binaryStatement.Right = statementInterpreterHandler.GetStatement(binaryExpressionSyntax.Right);
binaryStatement.Operand = GetOperand(binaryExpressionSyntax.Kind());
return(binaryStatement);
}
public Statement GetStatement()
{
var assignmentStatement = new BinaryStatement();
assignmentStatement.Left = statementInterpreterHandler.GetStatement(assignmentExpressionSyntax.Left)
;
assignmentStatement.Right = statementInterpreterHandler
.GetStatement(assignmentExpressionSyntax.Right);
assignmentStatement.Operand = GetOperand(assignmentExpressionSyntax.Kind());
return(assignmentStatement);
}
public object Create(VerbModel model, BinaryStatement statement)
{
var verb = this.execution.Operators.Models.Sources
.Select(source => source.Assembly)
.SelectMany(assembly => assembly.GetTypes())
.Where(type => type.GetInterfaces().Any(i => i.IsGenericType && typeof(IVerb <>) == i.GetGenericTypeDefinition()) && !type.IsAbstract)
.SingleOrDefault(type => type.GetConstructors().Any(ctor => ctor.GetParameters().Any(p => p.ParameterType.IsInstanceOfType(model))));
if (verb == null)
{
throw new Exception("Cannot find verb for the model " + model.GetType().FullName);
}
return(Activator.CreateInstance(verb, model, statement));
}
public void Visitor_Should_FindAllValueStatements()
{
// Arrange
var firstValue = "1";
var fifthValue = "5";
// Create first statement
var valueStatement1a = new ValueStatement(firstValue);
var valueStatement1b = new ValueStatement("2");
var binaryStatement1 = new BinaryStatement(valueStatement1a, valueStatement1b);
// Create second statement (nested)
var valueStatement2a = new ValueStatement("3");
var valueStatement22a = new ValueStatement("4");
var valueStatement22b = new ValueStatement(fifthValue);
var binaryStatement22 = new BinaryStatement(valueStatement22a, valueStatement22b);
var binaryStatement2 = new BinaryStatement(valueStatement2a, binaryStatement22);
var syntaxTree = new SyntaxTree(new[] { binaryStatement1, binaryStatement2 });
var result = new List <string>();
var syntaxTreeValueVisitor = new SyntaxTreeValueVisitor();
syntaxTreeValueVisitor.VisitResultEvent += (sender, e) =>
{
Trace.WriteLine(string.Format("Level {0}, Value Expression {1}", e.Depth, e.Value));
result.Add(e.Value);
};
// Act
// Run through the syntax tree with the simple value visitor
Trace.WriteLine("Start SyntaxTreeValueVisitor");
syntaxTree.Accept(syntaxTreeValueVisitor);
Trace.WriteLine("End SyntaxTreeValueVisitor");
Trace.WriteLine(string.Empty);
// Run through the syntax tree with the indent visitor
Trace.WriteLine("Start SyntaxTreeIndendedVisitor");
syntaxTree.Accept(new SyntaxTreeIndentVisitor());
Trace.WriteLine("End SyntaxTreeIndendedVisitor");
// Assert
Assert.AreEqual(5, result.Count);
Assert.AreEqual(firstValue, result[0]);
Assert.AreEqual(fifthValue, result[4]);
}
private Statement GetStatement(List <InterpolatedStringContentSyntax> contents)
{
if (contents.Count == 0)
{
return(new ConstantStatement(""));
}
if (contents.Count == 1)
{
return(GetStatement(contents[0]));
}
var binaryStatement = new BinaryStatement();
binaryStatement.Operand = BinaryOperand.Add;
binaryStatement.Left = GetStatement(contents[0]);
binaryStatement.Right = GetStatement(contents.Skip(1).ToList());
return(binaryStatement);
}
public Statement GetStatement()
{
var assignmentStatement = new BinaryStatement();
if (equalsValueClauseSyntax.Parent is VariableDeclaratorSyntax vds)
{
assignmentStatement.Left = new LocalIdentifierStatement
{
Name = vds.Identifier.Text
}
}
;
else
{
throw new NotSupportedException(equalsValueClauseSyntax.Parent.GetType() + " is not supported yet");
}
assignmentStatement.Right = statementInterpreterHandler
.GetStatement(equalsValueClauseSyntax.Value);
assignmentStatement.Operand = BinaryOperand.Assign;
return(assignmentStatement);
}
public BinaryExpressionInterpreter(ExpressionInterpreterHandler expressionInterpreterHandler, BinaryStatement binaryStatement)
{
this.expressionInterpreterHandler = expressionInterpreterHandler;
this.binaryStatement = binaryStatement;
}
