private static void ConvertInitializers(SeparatedSyntaxList <ExpressionSyntax> initializers, string instance, List <StatementSyntax> statements, List <InitializerInfo> infos)
{
var idx = 0;
foreach (var init in initializers)
{
var info = infos[idx++];
var mInfo = info != null && info.method != null ? info.method : null;
if (mInfo != null)
{
if (mInfo.IsStatic)
{
var ie = SyntaxHelper.GenerateStaticMethodCall(mInfo.Name,
mInfo.ContainingType.FullyQualifiedName(),
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(instance)),
SyntaxFactory.Argument(init.WithoutTrivia())
}, mInfo.TypeArguments.ToArray());
statements.Add(ie);
}
else
{
ArgumentSyntax[] arguments = null;
if (init.Kind() == SyntaxKind.ComplexElementInitializerExpression)
{
var complexInit = (InitializerExpressionSyntax)init;
arguments = new ArgumentSyntax[complexInit.Expressions.Count];
for (int i = 0; i < complexInit.Expressions.Count; i++)
{
arguments[i] = SyntaxFactory.Argument(complexInit.Expressions[i].WithoutTrivia());
}
}
else
{
arguments = new[]
{
SyntaxFactory.Argument(init.WithoutTrivia())
};
}
var ie = SyntaxHelper.GenerateMethodCall(mInfo.Name, instance, arguments, mInfo.TypeArguments.ToArray());
statements.Add(ie);
}
}
else
{
var be = (AssignmentExpressionSyntax)init;
if (be.Right is InitializerExpressionSyntax)
{
string name = null;
if (be.Left is IdentifierNameSyntax)
{
var identifier = (IdentifierNameSyntax)be.Left;
name = instance + "." + identifier.Identifier.ValueText;
}
else if (be.Left is ImplicitElementAccessSyntax)
{
name = SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(instance),
((ImplicitElementAccessSyntax)be.Left).ArgumentList.WithoutTrivia()).ToString();
}
else
{
name = instance;
}
SharpSixRewriter.ConvertInitializers(((InitializerExpressionSyntax)be.Right).Expressions, name, statements, info.nested);
}
else
{
var indexerKeys = be.Left as ImplicitElementAccessSyntax;
if (indexerKeys != null)
{
be = be.WithLeft(SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(instance),
indexerKeys.ArgumentList.WithoutTrivia()));
}
else
{
var identifier = (IdentifierNameSyntax)be.Left;
be =
be.WithLeft(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(instance),
SyntaxFactory.IdentifierName(identifier.Identifier.ValueText)));
}
be = be.WithRight(be.Right.WithoutTrivia());
be = be.WithoutTrivia();
statements.Add(SyntaxFactory.ExpressionStatement(be, SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
}
}
}
public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
bool needRewrite = false;
List <InitializerInfo> initializerInfos = null;
bool extensionMethodExists = false;
bool isImplicitElementAccessSyntax = false;
if (node.Initializer != null)
{
initializerInfos = new List <InitializerInfo>();
needRewrite = NeedRewriteInitializer(node.Initializer, initializerInfos, ref extensionMethodExists, ref isImplicitElementAccessSyntax);
}
node = (ObjectCreationExpressionSyntax)base.VisitObjectCreationExpression(node);
if (needRewrite)
{
if (this.IsExpressionOfT)
{
if (isImplicitElementAccessSyntax)
{
var mapped = this.semanticModel.SyntaxTree.GetLineSpan(node.Span);
throw new Exception(string.Format(CultureInfo.InvariantCulture, "{2} - {3}({0},{1}): {4}", mapped.StartLinePosition.Line + 1, mapped.StartLinePosition.Character + 1, "Index collection initializer is not supported inside Expression<T>", this.semanticModel.SyntaxTree.FilePath, node.ToString()));
}
if (extensionMethodExists)
{
var mapped = this.semanticModel.SyntaxTree.GetLineSpan(node.Span);
throw new Exception(string.Format(CultureInfo.InvariantCulture, "{2} - {3}({0},{1}): {4}", mapped.StartLinePosition.Line + 1, mapped.StartLinePosition.Character + 1, "Extension method for collection initializer is not supported inside Expression<T>", this.semanticModel.SyntaxTree.FilePath, node.ToString()));
}
return(node);
}
var initializers = node.Initializer.Expressions;
ExpressionSyntax[] args = new ExpressionSyntax[2];
var target = node.WithInitializer(null).WithoutTrivia();
if (target.ArgumentList == null)
{
target = target.WithArgumentList(SyntaxFactory.ArgumentList());
}
args[0] = target;
List <StatementSyntax> statements = new List <StatementSyntax>();
var parent = node.Parent;
while (parent != null && !(parent is MethodDeclarationSyntax) && !(parent is ClassDeclarationSyntax))
{
parent = parent.Parent;
}
string instance = "_o" + ++indexInstance;
if (parent != null)
{
var info = LocalUsageGatherer.GatherInfo(this.semanticModel, parent);
while (info.DirectlyOrIndirectlyUsedLocals.Any(s => s.Name == instance))
{
instance = "_o" + ++indexInstance;
}
}
SharpSixRewriter.ConvertInitializers(initializers, instance, statements, initializerInfos);
statements.Add(SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(instance).WithLeadingTrivia(SyntaxFactory.Space)));
var body = SyntaxFactory.Block(statements);
var lambda = SyntaxFactory.ParenthesizedLambdaExpression(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Parameter(SyntaxFactory.Identifier(instance)) })), body);
args[1] = lambda;
var methodIdentifier = SyntaxFactory.IdentifierName("Bridge.Script.CallFor");
var invocation = SyntaxFactory.InvocationExpression(methodIdentifier, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(args.Select(SyntaxFactory.Argument))));
return(invocation);
}
return(node);
}
