BadVariableDefinitionExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Reader.Token;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Parser.Expressions.Variables;
 
public class BadPropertyDefinitionExpression : BadExpression
{
    public BadPropertyDefinitionExpression(BadWordToken name,
                                           BadSourcePosition position,
                                           BadExpression getExpression,
                                           BadExpression? typeExpression = null,
                                           BadExpression? setExpression = null,
                                           bool isReadOnly = false) : base(false, position)
    {
        Name = name;
        IsReadOnly = isReadOnly;
        TypeExpression = typeExpression;
        GetExpression = getExpression;
        SetExpression = setExpression;
    }
 
    public BadWordToken Name { get; }
 
    public bool IsReadOnly { get; }
 
    public BadExpression? TypeExpression { get; }
 
    public BadExpression GetExpression { get; }
 
    public BadExpression? SetExpression { get; }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        yield return GetExpression;
 
        if (TypeExpression != null)
        {
            yield return TypeExpression;
        }
 
        if (SetExpression != null)
        {
            yield return SetExpression;
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        if (context.Scope.ClassObject == null)
        {
            throw BadRuntimeException.Create(context.Scope, "Can only define properties in class scope", Position);
        }
 
        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("Type expression must be a class prototype", Position);
            }
 
            type = proto;
        }
 
        List<BadObject> attributes = new List<BadObject>();
 
        foreach (BadObject? o in ComputeAttributes(context, attributes))
        {
            yield return o;
        }
 
        context.Scope.DefineProperty(Name.Text, type, GetExpression, SetExpression, context, attributes.ToArray());
    }
}
 
public class BadVariableDefinitionExpression : BadVariableExpression
{
    public BadVariableDefinitionExpression(string name,
                                           BadSourcePosition position,
                                           BadExpression? typeExpression = null,
                                           bool isReadOnly = false) : base(name,
                                                                           position,
                                                                           Array.Empty<BadExpression>()
                                                                          )
    {
        IsReadOnly = isReadOnly;
        TypeExpression = typeExpression;
    }
 
    public bool IsReadOnly { get; }
 
    public BadExpression? TypeExpression { get; }
 
    public override string ToString()
    {
        return IsReadOnly
                   ? $"{BadStaticKeys.CONSTANT_DEFINITION_KEY} {Name}"
                   : $"{BadStaticKeys.VARIABLE_DEFINITION_KEY} {Name}";
    }
 
    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 BadRuntimeException.Create(context.Scope, "Type expression must be a class prototype", Position);
            }
 
            type = proto;
        }
 
        if (type == BadVoidPrototype.Instance)
        {
            throw BadRuntimeException.Create(context.Scope, "Cannot declare a variable of type 'void'", Position);
        }
 
        if (context.Scope.HasLocal(Name, context.Scope, false))
        {
            throw BadRuntimeException.Create(context.Scope, $"Variable '{Name}' is already defined", Position);
        }
 
        List<BadObject> attributes = new List<BadObject>();
 
        foreach (BadObject? o in ComputeAttributes(context, attributes))
        {
            yield return o;
        }
 
        context.Scope.DefineVariable(Name,
                                     BadObject.Null,
                                     null,
                                     new BadPropertyInfo(type, IsReadOnly),
                                     attributes.ToArray()
                                    );
 
        foreach (BadObject o in base.InnerExecute(context))
        {
            yield return o;
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        if (TypeExpression != null)
        {
            foreach (BadExpression typeExpression in TypeExpression.GetDescendantsAndSelf())
            {
                yield return typeExpression;
            }
        }
 
        foreach (BadExpression descendant in base.GetDescendants())
        {
            yield return descendant;
        }
    }
}