// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
 
// This is needed due to NativeAOT which doesn't enable nullable globally yet
#nullable enable
 
namespace ILLink.Shared.DataFlow
{
    // Wrapper for Nullable<T> which implements IEquatable so that this may
    // be used as a lattice value. Nullable types can't satisfy interface constraints;
    // see for example https://learn.microsoft.com/dotnet/csharp/misc/cs0313.
    public struct Maybe<T> : IEquatable<Maybe<T>>, IDeepCopyValue<Maybe<T>>
        where T : struct, IEquatable<T>
    {
        public T? MaybeValue;
        public Maybe(T value) => MaybeValue = value;
        public bool Equals(Maybe<T> other) => MaybeValue?.Equals(other.MaybeValue) ?? other.MaybeValue == null;
        public override bool Equals(object? obj) => obj is Maybe<T> other && Equals(other);
        public override int GetHashCode() => MaybeValue?.GetHashCode() ?? 0;
        public Maybe<T> DeepCopy()
        {
            if (MaybeValue is not T value)
                return default;
            if (value is IDeepCopyValue<T> copyValue)
                return new(copyValue.DeepCopy());
            return new(value);
        }
 
        public static bool operator ==(Maybe<T> left, Maybe<T> right) => left.Equals(right);
        public static bool operator !=(Maybe<T> left, Maybe<T> right) => !(left == right);
    }
 
    public struct MaybeLattice<T, TValueLattice> : ILattice<Maybe<T>>
        where T : struct, IEquatable<T>
        where TValueLattice : ILattice<T>
    {
        public readonly TValueLattice ValueLattice;
        public MaybeLattice(TValueLattice valueLattice)
        {
            ValueLattice = valueLattice;
            Top = default;
        }
        public Maybe<T> Top { get; }
        public Maybe<T> Meet(Maybe<T> left, Maybe<T> right)
        {
            if (left.MaybeValue is not T leftValue)
                return right.DeepCopy();
            if (right.MaybeValue is not T rightValue)
                return left.DeepCopy();
            return new Maybe<T>(ValueLattice.Meet(leftValue, rightValue));
        }
    }
}