BadInvocationExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Parser.Expressions.Access;
using BadScript2.Parser.Expressions.Variables;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
 
namespace BadScript2.Parser.Expressions.Function;
 
public class BadInvocationExpression : BadExpression
{
    private readonly List<BadExpression> m_Arguments;
 
    public BadInvocationExpression(BadExpression left, IEnumerable<BadExpression> args, BadSourcePosition position) :
        base(false,
             position
            )
    {
        Left = left;
        m_Arguments = args.ToList();
    }
 
    public int ArgumentCount => m_Arguments.Count;
 
    public IEnumerable<BadExpression> Arguments => m_Arguments;
 
    public BadExpression Left { get; }
 
    public void SetArgs(IEnumerable<BadExpression> exprs)
    {
        m_Arguments.Clear();
        m_Arguments.AddRange(exprs);
    }
 
    public override void Optimize()
    {
        for (int i = 0; i < m_Arguments.Count; i++)
        {
            m_Arguments[i] = BadConstantFoldingOptimizer.Optimize(m_Arguments[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (BadExpression left in Left.GetDescendantsAndSelf())
        {
            yield return left;
        }
 
        foreach (BadExpression arg in m_Arguments.SelectMany(argument => argument.GetDescendantsAndSelf()))
        {
            yield return arg;
        }
    }
 
    public IEnumerable<BadObject> GetArgs(BadExecutionContext context, List<BadObject> args)
    {
        foreach (BadExpression argExpr in m_Arguments)
        {
            BadObject argObj = BadObject.Null;
 
            foreach (BadObject arg in argExpr.Execute(context))
            {
                argObj = arg;
 
                yield return arg;
            }
 
            args.Add(argObj.Dereference(argExpr.Position));
        }
    }
 
    public static IEnumerable<BadObject> Invoke(BadObject left,
                                                IEnumerable<BadObject> args,
                                                BadSourcePosition position,
                                                BadExecutionContext context)
    {
        if (left is BadFunction func)
        {
            foreach (BadObject o in func.Invoke(args.ToArray(), context))
            {
                yield return o;
            }
        }
        else if (left.HasProperty(BadStaticKeys.INVOCATION_OPERATOR_NAME, context.Scope))
        {
            if (left.GetProperty(BadStaticKeys.INVOCATION_OPERATOR_NAME, context.Scope)
                    .Dereference(position) is not BadFunction invocationOp)
            {
                throw new BadRuntimeException("Function Invocation Operator is not a function", position);
            }
 
            BadObject r = BadObject.Null;
 
            foreach (BadObject o in invocationOp.Invoke(args.ToArray(), context))
            {
                yield return o;
 
                r = o;
            }
 
            yield return r.Dereference(position);
        }
        else
        {
            throw new BadRuntimeException("Cannot invoke non-function object",
                                          position
                                         );
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject left = BadObject.Null;
 
        foreach (BadObject o in Left.Execute(context))
        {
            left = o;
 
            yield return o;
        }
 
        left = left.Dereference(Position);
 
        if (Left is IBadAccessExpression { NullChecked: true } && left.Equals(BadObject.Null))
        {
            yield return BadObject.Null;
 
            yield break;
        }
 
        if (Left is BadVariableExpression vExpr &&
            vExpr.Name == BadStaticKeys.BASE_KEY &&
            context.Scope.FunctionObject?.Name?.Text == BadStaticKeys.CONSTRUCTOR_NAME)
        {
            //Invoke Base Constructor
            left = left.GetProperty(BadStaticKeys.CONSTRUCTOR_NAME)
                       .Dereference(Position);
        }
 
        List<BadObject> args = new List<BadObject>();
 
        foreach (BadObject o in GetArgs(context, args))
        {
            yield return o;
        }
 
        foreach (BadObject? o in Invoke(left, args.ToArray(), Position, context))
        {
            yield return o;
        }
    }
 
    public override string ToString()
    {
        return $"({Left}({string.Join(", ", m_Arguments.Select(x => x.ToString()))}))";
    }
}