private string GenerateExceptionCreationExpression(ObjectCreationExpressionSyntax exceptionCreationExpressionSyntax, SemanticModel semanticModel)
{
var exceptionType = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, exceptionCreationExpressionSyntax).Type;
string exceptionTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(exceptionType);
string generatedExceptionName = "";
if (exceptionTypeFullName == "System.ArgumentNullException")
{
generatedExceptionName = "IllegalArgumentException";
}
else if (exceptionTypeFullName == "System.ArgumentException")
{
generatedExceptionName = "IllegalArgumentException";
}
else if (exceptionTypeFullName == "System.NullReferenceException")
{
generatedExceptionName = "NullPointerException";
}
else if (exceptionTypeFullName == "System.InvalidOperationException")
{
generatedExceptionName = "IllegalStateException";
}
else
{
throw new NotSupportedException();
}
string argumentList = ArgumentListGenerator.Generate(exceptionCreationExpressionSyntax.ArgumentList, semanticModel);
return("new " + generatedExceptionName + argumentList);
}
public void CreateArgumentListWithThreeExpressions()
{
var arguments = new List <ExpressionSyntax> {
SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("a")),
SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("b")),
SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("c"))
};
Assert.AreEqual("(a,b,c)", ArgumentListGenerator.CreateArgumentList(arguments).ToString());
}
private string GenerateObjectCreationExpression(ObjectCreationExpressionSyntax objectCreationExpressionSyntax, SemanticModel semanticModel)
{
var type = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, objectCreationExpressionSyntax).Type;
if (IsExceptionType(type))
{
return(GenerateExceptionCreationExpression(objectCreationExpressionSyntax, semanticModel));
}
string typeReference = TypeReferenceGenerator.GenerateTypeReference(type, semanticModel).Text;
string argumentList = ArgumentListGenerator.Generate(objectCreationExpressionSyntax.ArgumentList, semanticModel);
string constructorCall = "new " + typeReference + argumentList;
var initializer = objectCreationExpressionSyntax.Initializer;
if (initializer == null || !initializer.Expressions.Any())
{
return(constructorCall);
}
else
{
string objectToCreateName = "temp";
string initializations = "";
var expressions = objectCreationExpressionSyntax.Initializer.Expressions;
foreach (var expressionSyntax in expressions)
{
if (expressionSyntax is AssignmentExpressionSyntax)
{
var assignmentExpressionSyntax = expressionSyntax as AssignmentExpressionSyntax;
//string left = objectToCreateName + "." + GenerateExpression(assignmentExpressionSyntax.Left, semanticModel);
string expressionString = GenerateAssignmentExpression(assignmentExpressionSyntax, semanticModel);
initializations += objectToCreateName + "." + expressionString + ";\n";
}
else
{
//string left = objectToCreateName + "." + GenerateExpression(assignmentExpressionSyntax.Left, semanticModel);
string expressionString = GenerateExpression(expressionSyntax, semanticModel);
initializations += objectToCreateName + ".add(" + expressionString + ");\n";
}
}
string creationStatements = typeReference + " " + objectToCreateName + " = " + constructorCall + ";\n" +
initializations +
"return " + objectToCreateName + ";\n";
string constructAndInitialize = "((new by.besmart.cross.delegates.Func() {\n" +
"\t\tpublic " + typeReference + " invoke() {\n" +
creationStatements.AddTab(3) +
"}\n" +
"\t}).invoke())";
return(constructAndInitialize);
}
}
public void It_can_pass_through_multiple_arguments()
{
var argument = new { foo = 3 };
var secondArgument = new { bar = 2 };
var list = ArgumentListGenerator.GenerateArgumentListForGetProgramState(new FilePosition
{
Line = 1,
Character = 1,
File = "test.cs"
}, (argument, "foo"), (secondArgument, "bar"));
var text = list.ToString();
var expected = "(\"{\\\"line\\\":1,\\\"character\\\":1,\\\"file\\\":\\\"test.cs\\\"}\",(\"{\\\"foo\\\":3}\",foo),(\"{\\\"bar\\\":2}\",bar))";
Assert.Equal(expected, text);
}
private static ExpressionStatementSyntax _CreateParallelFor(ForStatementSyntax statement)
{
var variable = statement.Declaration.Variables.Single();
var from = variable.Initializer.Value;
// The analyzer only allows binary expressions where the upper bound is on the left hand-side.
// Therefore, no further checks are necessary.
var binary = (BinaryExpressionSyntax)statement.Condition;
var to = binary.Right;
if (binary.IsKind(SyntaxKind.LessThanOrEqualExpression))
{
// TODO maybe try to reduce resulting expressions like ...-1+1
to = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, to, _CreateOneLiteral());
}
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
MemberAccessGenerator.CreateMemberAccess("Parallel", "For"),
ArgumentListGenerator.CreateArgumentList(from, to, LambdaGenerator.CreateLambdaOrDelegate(variable.Identifier, statement.Statement))
)
).WithTriviaFrom(statement));
}
public void CreateArgumentListWithOneExpression()
{
var identifier = SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("a"));
Assert.AreEqual("(a)", ArgumentListGenerator.CreateArgumentList(identifier).ToString());
}
public void CreateArgumentListWithoutExpressions()
{
Assert.AreEqual("()", ArgumentListGenerator.CreateArgumentList().ToString());
}
