BadUsingExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Parser.Expressions.Function;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
 
namespace BadScript2.Parser.Expressions.Block;
 
public class BadUsingExpression : BadExpression
{
    private readonly BadExpression[] m_Expressions;
 
    public readonly string Name;
 
    private BadExpression m_Definition;
 
    public BadUsingExpression(string name, BadExpression[] expressions, BadSourcePosition position, BadExpression definition) : base(false, position)
    {
        Name = name;
        m_Expressions = expressions;
        m_Definition = definition;
    }
 
    public IEnumerable<BadExpression> Expressions => m_Expressions;
 
    public BadExpression Definition => m_Definition;
 
    public override void Optimize()
    {
        m_Definition = BadConstantFoldingOptimizer.Optimize(m_Definition);
        for (int i = 0; i < m_Expressions.Length; i++)
        {
            m_Expressions[i] = BadConstantFoldingOptimizer.Optimize(m_Expressions[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        return m_Expressions.SelectMany(expr => expr.GetDescendantsAndSelf());
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        using BadExecutionContext usingContext = new BadExecutionContext(
            context.Scope.CreateChild("UsingBlock", context.Scope, null)
        );
 
 
        foreach (BadObject o in usingContext.Execute(m_Definition))
        {
            yield return o;
        }
 
        if (m_Expressions.Length != 0)
        {
            foreach (BadObject o in usingContext.Execute(m_Expressions))
            {
                yield return o;
            }
        }
 
        // ReSharper disable once AccessToDisposedClosure
        usingContext.Scope.AddFinalizer(() => Finalize(usingContext, Name, Position));
 
        yield return BadObject.Null;
    }
 
    public static void Finalize(BadExecutionContext usingContext, string name, BadSourcePosition position)
    {
        BadObject obj = usingContext.Scope.GetVariable(name).Dereference();
 
        if (!obj.HasProperty("Dispose"))
        {
            throw BadRuntimeException.Create(usingContext.Scope, "Object does not implement IDisposable", position);
        }
 
        BadObject disposeFunc = obj.GetProperty("Dispose", usingContext.Scope).Dereference();
        foreach (BadObject? o in BadInvocationExpression.Invoke(disposeFunc, Array.Empty<BadObject>(), position, usingContext))
        {
            //Do Nothing
        }
    }
}