IConversionExpression Rework

[333fred]

using System;

class Program
{
    static void Main(string[] args)
    {
        IFormattable f1 = $"{1}";
    }
}

IOperation tree for "f1 = $"{1}""

IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'IFormattabl ... 1 = $"{1}";')
  IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'IFormattabl ... 1 = $"{1}";')
    Variables: Local_1: System.IFormattable f1
    Initializer: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.IFormattable) (Syntax: '$"{1}"')
        IInterpolatedStringExpression (OperationKind.InterpolatedStringExpression, Type: System.String) (Syntax: '$"{1}"')
          Parts(1): IInterpolation (OperationKind.Interpolation) (Syntax: '{1}')
              Expression: ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')

Note the ConversionKind.Invalid. This is because the underlying BoundConversion has ConversionKind.InterpolatedString, which is not in our public API. This conversion is part of the C# spec, and should be reflected as a conversion type in the IOperation tree. FYI @mavasani @dotnet/analyzer-ioperation.

[333fred]

Note: this should probably be represented as ConversionKind.CSharp, unless we think that there is a plan to add interpolated strings with similar semantics to VB.

[333fred]

Design Team Decision:
We should do this.

[333fred]

@AlekseyTs had some comments on this in #20416 (comment).

[333fred]

Design Team Decision:
May be as a headstart , we should say for Iconversionexpression you can get conversion struct so you can do what ever you want , we can go and experiment to bring parity in both.

[CyrusNajmabadi]

I think we should also start pulling together a common type that has values we know are always safe to get back to. This could be an object that also allows one to get back to the language specific structs (through extenesion methods at the individual language layers) for features that need exact, rich, language specific data. i.e. we could have:

public abstract class CommonConversion {
   // common stuff
}

// C# layer
internal class CSharpConversion : CommonConversion {
     public readonly Conversion UnderlyingConversion;
}

...

public static Conversion GetCSharpConversion(this CommonConversion conversion)
     => ((CSharpConversion)conversion).UnderlyingConversion;

[333fred]

@CyrusNajmabadi and I have talked about this offline, and here's what I'm proposing for V1:

• IConversionExpression will become a wrapper around the VB and C# Conversion structs and the target of the conversion.
• We will create an interface IConversion for the C# and VB Conversion structs. For right now, this will only have information that is directly equivalent between the languages, with no translation necessar. There are a few things that Cyrus and I think we should be able to add to this interface without too much controversy, such as Exists, IsIdentity, IsNumeric, IsUserDefined, MethodSymbol, and possibly IsNullable. More advanced checks can come from a later proposal.

New IConversionExpression:

    /// <summary>
    /// Represents a conversion operation.
    /// </summary>
    /// <remarks>
    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
    /// change it in the future.
    /// </remarks>
    public interface IConversionExpression
    {
        /// <summary>
        /// Value to be converted.
        /// </summary>
        IOperation Operand { get; }
        /// <summary>
        /// Gets the underlying conversion. This will be either <see cref="Microsoft.CodeAnalysis.CSharp.Conversion"/>
        /// or <see cref="Microsoft.CodeAnalysis.VisualBasic.Conversion"/>.
        /// </summary>
        /// <typeparam name="TConversion">The specific conversion kind for the language of the code.</typeparam>
        /// <returns>The conversion struct. If the wrong conversion type is specified, a <see cref="ArgumentException"/> will be thrown.</returns>
        TConversion GetConversion<TConversion>() where TConversion : struct, IConversion;
        /// <summary>
        /// True if and only if the conversion is indicated explicity by a cast operation in the source code.
        /// </summary>
        bool IsExplicitInCode { get; }
        /// <summary>
        /// The language that defined this conversion. Possible values are <see cref="LanguageNames.CSharp"/> and
        /// <see cref="LanguageNames.VisualBasic"/>.
        /// </summary>
        string LanguageName { get; }
    }

New IConversion:

/// <summary>
/// Represents a conversion that is convertible to a language-specific conversion. This can be either
/// a <see cref="Microsoft.CodeAnalysis.CSharp.Conversion"/> or 
/// <see cref="Microsoft.CodeAnalysis.VisualBasic.Conversion"/>.
/// <remarks>
/// This interface is reserved for implementation by its associated APIs. We reserve the right to
/// change it in the future.
/// </remarks>
public interface IConversion
{
    /// <summary>
    /// Returns true if the conversion exists, as defined by the target language.
    /// </summary>
    /// <remarks>
    /// The existence of a conversion does not necessarily imply that the conversion is valid.
    /// For example, an ambiguous user-defined conversion may exist but may not be valid.
    /// </remarks>
    public bool Exists { get; }
    /// <summary>
    /// Returns true if the conversion is an identity conversion.
    /// </summary>
    public bool IsIdentity { get; }
    /// <summary>
    /// Returns true if the conversion is a numeric conversion.
    /// </summary>
    public bool IsNumeric { get; } 
    /// <summary>
    /// Returns true if the conversion is a user-defined conversion.
    /// </summary>
    public bool IsUserDefined { get; }
    /// <summary>
    /// Returns the method used to perform the conversion for a user-defined conversion if <see cref="IsUserDefined"/> is true.
    /// Otherwise, returns null.
    /// </summary>
    public IMethodSymbol MethodSymbol { get; }
}

[333fred]

Fixed in #21040.