// 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
{
	// ITransfer represents the transfer functions for a dataflow analysis.
	// The transfer functions compute the effects of an operation on the set of facts
	// tracked by a dataflow analysis. This simulates the execution of the operation
	// on the domain of abstract values tracked in the dataflow analysis.
 
	// TValue is the type of the information tracked in a dataflow analysis at each program point.
	// TLattice is the type of the lattice formed by these values.
 
	// TOperation is a type representing the operations that the transfer function
	// "simulates". It isn't constrained by the interface, but is typically a basic block,
	// where the transfer functions are defined in terms of transfer functions for individual
	// operations in the block.
 
	// TLattice isn't typically used in the implementation except to provide the "Top" value.
	// This expresses the conceptual constraint that the transferred values are part of a lattice.
	public interface ITransfer<TOperation, TValue, TState, TLattice, TConditionValue>
		where TValue : struct, IEquatable<TValue>
		where TState : class, IDataFlowState<TValue, TLattice>
		where TLattice : ILattice<TValue>
		where TConditionValue : struct, INegate<TConditionValue>
	{
		// Transfer should mutate the input value to reflect the effect of
		// computing this operation. When using value types, ensure that
		// any modifications to the values are observable by the caller (consider
		// using readonly structs to prevent the implementation from making changes
		// that won't be reflected in the caller).
		// The optional return value can be used to model branch conditions.
		TConditionValue? Transfer (TOperation operation, TState state);
 
		// Applies a condition value to a dataflow value. This is called in the
		// outgoing branch of a basic block which returns a TConditionValue
		// to model the state in the conditional branch where the condition is
		// assumed to be true.
		void ApplyCondition (TConditionValue condition, ref TValue value);
	}
 
	public interface INegate<TValue>
	{
		TValue Negate ();
	}
}