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; }
 
 
    public string? GetName()
    {
        return Name?.Text;
    }
 
    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();
 
            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)
        {
            var attributes = new List<BadObject>();
            foreach (var 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;
    }
}