BadInterfacePrototype.cs

Go to the documentation of this file.

using BadScript2.Parser;
using BadScript2.Reader.Token;
using BadScript2.Runtime.Error;
 
namespace BadScript2.Runtime.Objects.Types.Interface;
 
public class BadInterfacePrototype : BadClassPrototype, IBadGenericObject
{
    private readonly Dictionary<int, BadInterfacePrototype> s_GenericCache = new Dictionary<int, BadInterfacePrototype>();
    private static readonly BadClassPrototype s_Prototype = new BadNativeClassPrototype<BadClassPrototype>(
        "Interface",
        (_, _) => throw new BadRuntimeException("Interfaces cannot be extended")
    );
 
    public bool IsGeneric => GenericParameters.Count != 0;
 
    public string GenericName { get; }
    private readonly Func<BadObject[], BadInterfaceConstraint[]> m_ConstraintsFunc;
    
    private readonly Func<BadObject[], BadInterfacePrototype[]> m_InterfacesFunc;
    private BadInterfacePrototype[]? m_Interfaces;
 
    private BadInterfaceConstraint[]? m_Constraints;
 
    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>());
 
    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}";
    }
 
    public bool IsResolved { get; }
    private readonly BadInterfacePrototype? m_GenericDefinition;
    public IReadOnlyCollection<string> GenericParameters { get; }
 
    public BadObject CreateGeneric(BadObject[] args)
    {
        if(GenericParameters.Count != args.Length)
            throw new BadRuntimeException("Invalid Generic Argument Count");
        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;
    }
}