BadFunctionExpression.cs

Go to the documentation of this file.

using System.Text;
 
using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Reader.Token;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Types;
using BadScript2.Runtime.VirtualMachine.Compiler;
 
namespace BadScript2.Parser.Expressions.Function;
 
public class BadFunctionExpression : BadExpression, IBadNamedExpression
{
    private readonly List<BadExpression> m_Body;
 
 
    private readonly BadMetaData? m_MetaData;
 
    private readonly List<BadFunctionParameter> m_Parameters;
 
    public BadFunctionExpression(BadWordToken? name,
                                 List<BadFunctionParameter> parameter,
                                 List<BadExpression> block,
                                 BadSourcePosition position,
                                 bool isConstant,
                                 BadMetaData? metaData,
                                 bool isSingleLine,
                                 bool isStatic,
                                 BadFunctionCompileLevel compileLevel = BadFunctionCompileLevel.None,
                                 BadExpression? typeExpr = null) :
        base(false, position)
    {
        Name = name;
        m_Parameters = parameter;
        m_Body = block;
        TypeExpression = typeExpr;
        IsConstantFunction = isConstant;
        m_MetaData = metaData;
        IsSingleLine = isSingleLine;
        IsStatic = isStatic;
        CompileLevel = compileLevel;
    }
 
    public bool IsSingleLine { get; }
 
    public bool IsConstantFunction { get; }
 
    public bool IsStatic { get; }
 
    public BadExpression? TypeExpression { get; }
 
    public IEnumerable<BadFunctionParameter> Parameters => m_Parameters;
 
    public IEnumerable<BadExpression> Body => m_Body;
 
    public BadWordToken? Name { get; private set; }
 
    public BadFunctionCompileLevel CompileLevel { get; private set; }
 
#region IBadNamedExpression Members
 
    public string? GetName()
    {
        return Name?.Text;
    }
 
#endregion
 
    public void SetName(string name)
    {
        Name = name;
    }
 
    public void SetCompileLevel(BadFunctionCompileLevel level)
    {
        CompileLevel = level;
    }
 
    public void SetBody(IEnumerable<BadExpression> body)
    {
        m_Body.Clear();
        m_Body.AddRange(body);
    }
 
    public override void Optimize()
    {
        for (int i = 0; i < m_Body.Count; i++)
        {
            m_Body[i] = BadConstantFoldingOptimizer.Optimize(m_Body[i]);
        }
    }
 
    public string GetHeader()
    {
        string level = CompileLevel switch
        {
            BadFunctionCompileLevel.Compiled     => "compiled ",
            BadFunctionCompileLevel.CompiledFast => "compiled fast",
            _                                    => "",
        };
 
        return
            $"{level}{BadStaticKeys.FUNCTION_KEY} {Name?.ToString() ?? "<anonymous>"}({string.Join(", ", Parameters.Cast<object>())})";
    }
 
 
    public override string ToString()
    {
        StringBuilder sb = new StringBuilder(GetHeader());
        sb.AppendLine();
        sb.AppendLine("{");
 
        foreach (BadExpression expression in Body)
        {
            sb.AppendLine($"\t{expression}");
        }
 
        sb.AppendLine("}");
 
        return sb.ToString();
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        if (TypeExpression != null)
        {
            foreach (BadExpression typeExpr in TypeExpression.GetDescendantsAndSelf())
            {
                yield return typeExpr;
            }
        }
 
        foreach (BadFunctionParameter parameter in m_Parameters)
        {
            if (parameter.TypeExpr == null)
            {
                continue;
            }
 
            foreach (BadExpression typeExpr in parameter.TypeExpr.GetDescendantsAndSelf())
            {
                yield return typeExpr;
            }
        }
 
        foreach (BadExpression descendant in m_Body.SelectMany(expression => expression.GetDescendantsAndSelf()))
        {
            yield return descendant;
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadClassPrototype type = BadAnyPrototype.Instance;
 
        if (TypeExpression != null)
        {
            BadObject obj = BadObject.Null;
 
            foreach (BadObject o in TypeExpression.Execute(context))
            {
                obj = o;
 
                yield return o;
            }
 
            obj = obj.Dereference(Position);
 
            if (obj is not BadClassPrototype proto)
            {
                throw new BadRuntimeException($"Expected class prototype, but got {obj.GetType().Name}",
                                              Position
                                             );
            }
 
            type = proto;
        }
 
        BadExpressionFunction f = new BadExpressionFunction(context.Scope,
                                                            Name,
                                                            m_Body,
                                                            m_Parameters.Select(x => x.Initialize(context))
                                                                        .ToArray(),
                                                            Position,
                                                            IsConstantFunction,
                                                            IsStatic,
                                                            m_MetaData,
                                                            type,
                                                            IsSingleLine
                                                           );
 
        BadFunction fFinal = CompileLevel switch
        {
            BadFunctionCompileLevel.Compiled     => BadCompilerApi.CompileFunction(f, true),
            BadFunctionCompileLevel.CompiledFast => BadCompilerApi.CompileFunction(f, false),
            _                                    => f,
        };
 
        if (Name != null)
        {
            List<BadObject>? attributes = new List<BadObject>();
 
            foreach (BadObject? o in ComputeAttributes(context, attributes))
            {
                yield return o;
            }
 
            context.Scope.DefineVariable(Name.Text,
                                         fFinal,
                                         null,
                                         new BadPropertyInfo(fFinal.GetPrototype()),
                                         attributes.ToArray()
                                        );
        }
        else
        {
            if (Attributes.Any())
            {
                throw new BadRuntimeException("Anonymous functions cannot have attributes",
                                              Position
                                             );
            }
        }
 
        yield return fFinal;
    }
}