void EnsureExpressionStatementsAreValid(AstNode rootNode)
{
foreach (var stmt in rootNode.DescendantsAndSelf.OfType <ExpressionStatement>())
{
if (!IsValidInStatementExpression(stmt.Expression))
{
// fetch ILFunction
var function = stmt.Ancestors.SelectMany(a => a.Annotations.OfType <ILFunction>()).First(f => f.Parent == null);
// if possible use C# 7.0 discard-assignment
if (context.Settings.Discards && !ExpressionBuilder.HidesVariableWithName(function, "_"))
{
stmt.Expression = new AssignmentExpression(
new IdentifierExpression("_"), // no ResolveResult
stmt.Expression.Detach());
}
else
{
// assign result to dummy variable
var type = stmt.Expression.GetResolveResult().Type;
var v = function.RegisterVariable(
VariableKind.StackSlot,
type,
AssignVariableNames.GenerateVariableName(function, type,
stmt.Expression.Annotations.OfType <ILInstruction>()
.Where(AssignVariableNames.IsSupportedInstruction).FirstOrDefault(),
mustResolveConflicts: true)
);
stmt.Expression = new AssignmentExpression(
new IdentifierExpression(v.Name).WithRR(new ILVariableResolveResult(v, v.Type)),
stmt.Expression.Detach());
}
}
}
}
protected internal override Statement VisitUsingInstruction(UsingInstruction inst)
{
var transformed = TransformToForeach(inst, out var resource);
if (transformed != null)
{
return(transformed);
}
AstNode usingInit = resource;
var var = inst.Variable;
if (!inst.ResourceExpression.MatchLdNull() && !NullableType.GetUnderlyingType(var.Type).GetAllBaseTypes().Any(b => b.IsKnownType(KnownTypeCode.IDisposable)))
{
var.Kind = VariableKind.Local;
var disposeType = exprBuilder.compilation.FindType(KnownTypeCode.IDisposable);
var disposeVariable = currentFunction.RegisterVariable(
VariableKind.Local, disposeType,
AssignVariableNames.GenerateVariableName(currentFunction, disposeType)
);
return(new BlockStatement {
new ExpressionStatement(new AssignmentExpression(exprBuilder.ConvertVariable(var).Expression, resource.Detach())),
new TryCatchStatement {
TryBlock = ConvertAsBlock(inst.Body),
FinallyBlock = new BlockStatement()
{
new ExpressionStatement(new AssignmentExpression(exprBuilder.ConvertVariable(disposeVariable).Expression, new AsExpression(exprBuilder.ConvertVariable(var).Expression, exprBuilder.ConvertType(disposeType)))),
new IfElseStatement {
Condition = new BinaryOperatorExpression(exprBuilder.ConvertVariable(disposeVariable), BinaryOperatorType.InEquality, new NullReferenceExpression()),
TrueStatement = new ExpressionStatement(new InvocationExpression(new MemberReferenceExpression(exprBuilder.ConvertVariable(disposeVariable).Expression, "Dispose")))
}
}
},
});
}
else
{
if (var.LoadCount > 0 || var.AddressCount > 0)
{
var type = settings.AnonymousTypes && var.Type.ContainsAnonymousType() ? new SimpleType("var") : exprBuilder.ConvertType(var.Type);
var vds = new VariableDeclarationStatement(type, var.Name, resource);
vds.Variables.Single().AddAnnotation(new ILVariableResolveResult(var, var.Type));
usingInit = vds;
}
return(new UsingStatement {
ResourceAcquisition = usingInit,
EmbeddedStatement = ConvertAsBlock(inst.Body)
});
}
}
void EnsureExpressionStatementsAreValid(AstNode rootNode)
{
foreach (var stmt in rootNode.DescendantsAndSelf.OfType <ExpressionStatement>())
{
if (!IsValidInStatementExpression(stmt.Expression))
{
// fetch ILFunction
var function = stmt.Ancestors.SelectMany(a => a.Annotations.OfType <ILFunction>()).First(f => f.Parent == null);
// assign result to dummy variable
var type = stmt.Expression.GetResolveResult().Type;
var v = function.RegisterVariable(
VariableKind.StackSlot,
type,
AssignVariableNames.GenerateVariableName(function, type, stmt.Expression.Annotations.OfType <ILInstruction>().Where(AssignVariableNames.IsSupportedInstruction).FirstOrDefault())
);
stmt.Expression = new AssignmentExpression(
new IdentifierExpression(v.Name).WithRR(new ILVariableResolveResult(v, v.Type)),
stmt.Expression.Detach());
}
}
}
