private static SyntaxNode CreateRootAddingDisposeToEndOfMethod(SyntaxNode root, ExpressionStatementSyntax statement, ILocalSymbol identitySymbol)
{
var method = statement.FirstAncestorOrSelf<MethodDeclarationSyntax>();
var newDispose = ImplementsDisposableExplicitly(identitySymbol.Type)
? SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ParenthesizedExpression(SyntaxFactory.CastExpression(SyntaxFactory.ParseName("System.IDisposable").WithAdditionalAnnotations(Simplifier.Annotation), SyntaxFactory.IdentifierName(identitySymbol.Name))),
SyntaxFactory.IdentifierName("Dispose"))))
: SyntaxFactory.ParseStatement($"{identitySymbol.Name}.Dispose();");
newDispose = newDispose.WithAdditionalAnnotations(Formatter.Annotation);
var last = method.Body.Statements.Last();
var newRoot = root.InsertNodesAfter(method.Body.Statements.Last(), new[] { newDispose });
return newRoot;
}
public bool TryUnwrapJsniStatement(ExpressionStatementSyntax statement, out JsStatement result)
{
var expression = statement.Expression;
if (expression is InvocationExpressionSyntax)
{
var jsniInvocation = (InvocationExpressionSyntax)expression;
var symbolInfo = Context.Instance.Compilation.GetSemanticModel(expression.SyntaxTree).GetSymbolInfo(jsniInvocation);
var method = (IMethodSymbol)symbolInfo.Symbol;
var arguments = jsniInvocation.ArgumentList.Arguments.Select(x => (JsExpression)x.Accept(transformer)).ToArray();
if (symbolInfo.Symbol == null)
{
var classText = statement.FirstAncestorOrSelf<ClassDeclarationSyntax>().NormalizeWhitespace().ToString();
var diagnostics = transformer.model.GetDiagnostics().Select(x => x.ToString()).ToArray();
}
if (method.ReducedFrom != null && !method.ReducedFrom.Equals(method))
{
method = method.ReducedFrom;
var target = (JsExpression)jsniInvocation.Expression.Accept(transformer);
var methodTarget = target is JsMemberReferenceExpression ? ((JsMemberReferenceExpression)target).Target : target;
arguments = new[] { methodTarget }.Concat(arguments).ToArray();
}
if (method != null && Equals(method.ContainingType, Context.Instance.JsniType))
{
switch (method.Name)
{
case "forin":
var target = arguments[0];
var invocation = (JsInvocationExpression)arguments[1];
var function = (JsFunction)invocation.Arguments[1];
result = Js.ForIn(function.Parameters[0].Name, target).Body(function.Body);
return true;
}
}
}
result = null;
return false;
}