BadInterfacePrototype.cs

Go to the documentation of this file.

using BadScript2.Parser;
using BadScript2.Runtime.Error;
 
namespace BadScript2.Runtime.Objects.Types.Interface;
 
public class BadInterfacePrototype : BadClassPrototype, IBadGenericObject
{
    private static readonly BadClassPrototype s_Prototype = new BadNativeClassPrototype<BadClassPrototype>("Interface",
                                                                                                           (_, _) => throw new BadRuntimeException("Interfaces cannot be extended"),
                                                                                                           null
                                                                                                          );
 
    private readonly Func<BadObject[], BadInterfaceConstraint[]> m_ConstraintsFunc;
 
    private readonly BadInterfacePrototype? m_GenericDefinition;
 
    private readonly Func<BadObject[], BadInterfacePrototype[]> m_InterfacesFunc;
 
    private readonly Dictionary<int, BadInterfacePrototype> s_GenericCache =
        new Dictionary<int, BadInterfacePrototype>();
 
    private BadInterfaceConstraint[]? m_Constraints;
 
    private BadInterfacePrototype[]? m_Interfaces;
 
    public BadInterfacePrototype(string name,
                                 Func<BadObject[], BadInterfacePrototype[]> interfaces,
                                 BadMetaData? metaData,
                                 Func<BadObject[], BadInterfaceConstraint[]> constraints,
                                 string[] genericParameters) : base(name,
                                                                    metaData
                                                                   )
    {
        m_ConstraintsFunc = constraints;
        GenericParameters = genericParameters;
        m_InterfacesFunc = interfaces;
 
        if (IsGeneric)
        {
            GenericName = $"{name}<{string.Join(", ", genericParameters)}>";
        }
        else
        {
            GenericName = name;
        }
    }
 
    private BadInterfacePrototype(string name,
                                  Func<BadObject[], BadInterfacePrototype[]> interfaces,
                                  BadMetaData? metaData,
                                  Func<BadObject[], BadInterfaceConstraint[]> constraints,
                                  string[] genericParameters,
                                  BadInterfacePrototype genericDefinition,
                                  string genericName) : base(name,
                                                             metaData
                                                            )
    {
        GenericName = genericName;
        m_ConstraintsFunc = constraints;
        m_InterfacesFunc = interfaces;
        IsResolved = true;
        GenericParameters = genericParameters;
        m_GenericDefinition = genericDefinition;
    }
 
 
    protected override BadClassPrototype? BaseClass { get; }
 
    public override bool IsAbstract => true;
 
    public override IReadOnlyCollection<BadInterfacePrototype> Interfaces =>
        m_Interfaces ??= m_InterfacesFunc(Array.Empty<BadObject>());
 
    public IEnumerable<BadInterfaceConstraint> Constraints =>
        m_Constraints ??= m_ConstraintsFunc(Array.Empty<BadObject>());
 
#region IBadGenericObject Members
 
    public bool IsGeneric => GenericParameters.Count != 0;
 
    public string GenericName { get; }
 
    public bool IsResolved { get; }
 
    public IReadOnlyCollection<string> GenericParameters { get; }
 
    public BadObject CreateGeneric(BadObject[] args)
    {
        if (GenericParameters.Count != args.Length)
        {
            throw new BadRuntimeException("Invalid Generic Argument Count");
        }
 
        if (GenericParameters.Count == 0)
        {
            return this;
        }
 
        if (IsResolved)
        {
            throw new BadRuntimeException("Interface is already resolved");
        }
 
        int hash = args[0]
            .GetHashCode();
 
        //Add the other arguments to the hash
        for (int i = 1; i < args.Length; i++)
        {
            hash = (hash * 397) ^
                   args[i]
                       .GetHashCode();
        }
 
        if (s_GenericCache.TryGetValue(hash, out BadInterfacePrototype? cached))
        {
            return cached;
        }
 
        BadClassPrototype[] types = args.Cast<BadClassPrototype>()
                                        .ToArray();
 
        BadInterfacePrototype result = new BadInterfacePrototype(Name,
                                                                 _ => m_InterfacesFunc(args),
                                                                 MetaData,
                                                                 _ => m_ConstraintsFunc(args),
                                                                 GenericParameters.ToArray(),
                                                                 this,
                                                                 $"{Name}<{string.Join(", ", types.Select(x => x is IBadGenericObject g ? g.GenericName : x.Name))}>"
                                                                );
        s_GenericCache[hash] = result;
 
        return result;
    }
 
#endregion
 
    public override BadClassPrototype GetPrototype()
    {
        return s_Prototype;
    }
 
    public override IEnumerable<BadObject> CreateInstance(BadExecutionContext caller, bool setThis = true)
    {
        throw BadRuntimeException.Create(caller.Scope, "Interfaces cannot be instantiated");
    }
 
    public override bool IsSuperClassOf(BadClassPrototype proto)
    {
        return (GenericParameters.Count != 0 &&
                proto is BadInterfacePrototype iProto &&
                iProto.m_GenericDefinition == this) ||
               base.IsSuperClassOf(proto) ||
               proto.Interfaces.Any(IsSuperClassOf);
    }
 
 
    public override string ToSafeString(List<BadObject> done)
    {
        if (IsGeneric)
        {
            return IsResolved
                       ? $"interface {GenericName}"
                       : $"interface {Name}<{string.Join(", ", GenericParameters)}>";
        }
 
        return $"interface {Name}";
    }
}