Conversion expression rewrite

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.Semantics;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -903,6 +904,17 @@ public override int GetHashCode()
             return !(left == right);
         }
 
+        public static implicit operator CommonConversion(Conversion csharpConversion)
+        {
+            var methodSymbol = csharpConversion.IsUserDefined ? csharpConversion.MethodSymbol : null;
+            return new CommonConversion(csharpConversion.Exists,
+                                        csharpConversion.IsIdentity,
+                                        csharpConversion.IsNumeric,
+                                        csharpConversion.IsReference,
+                                        csharpConversion.IsUserDefined,
+                                        methodSymbol);
+        }
+
 #if DEBUG
         internal string Dump()
         {

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -5108,4 +5108,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_InvalidDebugInfo" xml:space="preserve">
     <value>Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}'</value>
   </data>
+  <data name="IConversionExpressionIsNotCSharpConversion" xml:space="preserve">
+    <value>{0} '{1}' is not a valid C# conversion expression</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Operations/CSharpConversionExpression.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using Microsoft.CodeAnalysis.Semantics;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal abstract class BaseCSharpConversionExpression : BaseConversionExpression
+    {
+        protected BaseCSharpConversionExpression(Conversion conversion, bool isExplicitInCode, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(conversion, isExplicitInCode, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
+        {
+            ConversionInternal = conversion;
+        }
+
+        internal Conversion ConversionInternal { get; }
+
+        public override string LanguageName => LanguageNames.CSharp;
+    }
+
+    internal sealed partial class CSharpConversionExpression : BaseCSharpConversionExpression
+    {
+        public CSharpConversionExpression(IOperation operand, Conversion conversion, bool isExplicit, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(conversion, isExplicit, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
+        {
+            Operand = operand;
+        }
+
+        public override IOperation Operand { get; }
+    }
+
+    internal sealed partial class LazyCSharpConversionExpression : BaseCSharpConversionExpression
+    {
+        private readonly Lazy<IOperation> _operand;
+        public LazyCSharpConversionExpression(Lazy<IOperation> operand, Conversion conversion, bool isExplicit, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(conversion, isExplicit, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
+        {
+            _operand = operand;
+        }
+
+        public override IOperation Operand => _operand.Value;
+    }
+
+    public static class IConversionExpressionExtensions
+    {
+        /// <summary>
+        /// Gets the underlying <see cref="Conversion"/> information from this <see cref="IConversionExpression"/>. This
+        /// <see cref="IConversionExpression"/> must have been created from CSharp code.
+        /// </summary>
+        /// <param name="conversionExpression">The conversion expression to get original info from.</param>
+        /// <returns>The underlying <see cref="Conversion"/>.</returns>
+        /// <exception cref="InvalidCastException">If the <see cref="IConversionExpression"/> was not created from CSharp code.</exception>
+        public static Conversion GetConversion(this IConversionExpression conversionExpression)
+        {
+            if (conversionExpression is BaseCSharpConversionExpression csharpConversionExpression)
+            {
+                return csharpConversionExpression.ConversionInternal;
+            }
+            else
+            {
+                throw new ArgumentException(string.Format(CSharpResources.IConversionExpressionIsNotCSharpConversion,
+                                                          nameof(IConversionExpression),
+                                                          conversionExpression));
+            }
+        }
+    }
+}

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

@@ -581,28 +581,28 @@ private IOperation CreateBoundConversionOperation(BoundConversion boundConversio
             else
             {
                 Lazy<IOperation> operand = new Lazy<IOperation>(() => Create(boundConversion.Operand));
-
-                bool isExplicit = boundConversion.ExplicitCastInCode;
-                bool usesOperatorMethod = boundConversion.ConversionKind == CSharp.ConversionKind.ExplicitUserDefined || boundConversion.ConversionKind == CSharp.ConversionKind.ImplicitUserDefined;
-                IMethodSymbol operatorMethod = boundConversion.SymbolOpt;
                 SyntaxNode syntax = boundConversion.Syntax;
+                Conversion conversion = _semanticModel.GetConversion(syntax);
+                bool isExplicit = boundConversion.ExplicitCastInCode;
+                bool throwsExceptionOnFailure = true;
+                bool isChecked = boundConversion.Checked;
                 ITypeSymbol type = boundConversion.Type;
                 Optional<object> constantValue = ConvertToOptional(boundConversion.ConstantValue);
-                return new LazyConversionExpression(operand, conversionKind, isExplicit, usesOperatorMethod, operatorMethod, syntax, type, constantValue);
+                return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isChecked, throwsExceptionOnFailure, syntax, type, constantValue);
             }
         }
 
         private IConversionExpression CreateBoundAsOperatorOperation(BoundAsOperator boundAsOperator)
         {
             Lazy<IOperation> operand = new Lazy<IOperation>(() => Create(boundAsOperator.Operand));
-            ConversionKind conversionKind = Semantics.ConversionKind.TryCast;
-            bool isExplicit = true;
-            bool usesOperatorMethod = false;
-            IMethodSymbol operatorMethod = null;
             SyntaxNode syntax = boundAsOperator.Syntax;
+            Conversion conversion = _semanticModel.GetConversion(syntax);
+            bool isExplicit = true;
+            bool throwsExceptionOnFailure = false;
+            bool isChecked = false;
             ITypeSymbol type = boundAsOperator.Type;
             Optional<object> constantValue = ConvertToOptional(boundAsOperator.ConstantValue);
-            return new LazyConversionExpression(operand, conversionKind, isExplicit, usesOperatorMethod, operatorMethod, syntax, type, constantValue);
+            return new LazyCSharpConversionExpression(operand, conversion, isExplicit, throwsExceptionOnFailure, isChecked, syntax, type, constantValue);
         }
 
         private IIsTypeExpression CreateBoundIsOperatorOperation(BoundIsOperator boundIsOperator)

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -1 +1,4 @@
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_2 = 702 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
+Microsoft.CodeAnalysis.CSharp.IConversionExpressionExtensions
+static Microsoft.CodeAnalysis.CSharp.IConversionExpressionExtensions.GetConversion(this Microsoft.CodeAnalysis.Semantics.IConversionExpression conversionExpression) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.Conversion.implicit operator Microsoft.CodeAnalysis.Semantics.CommonConversion(Microsoft.CodeAnalysis.CSharp.Conversion csharpConversion) -> Microsoft.CodeAnalysis.Semantics.CommonConversion

src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs

@@ -1296,34 +1296,23 @@ public LazyConditionalChoiceExpression(Lazy<IOperation> condition, Lazy<IOperati
     /// </summary>
     internal abstract partial class BaseConversionExpression : Operation, IHasOperatorMethodExpression, IConversionExpression
     {
-        protected BaseConversionExpression(ConversionKind conversionKind, bool isExplicit, bool usesOperatorMethod, IMethodSymbol operatorMethod, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        protected BaseConversionExpression(CommonConversion conversion, bool isExplicitInCode, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
                     base(OperationKind.ConversionExpression, syntax, type, constantValue)
         {
-            ConversionKind = conversionKind;
-            IsExplicit = isExplicit;
-            UsesOperatorMethod = usesOperatorMethod;
-            OperatorMethod = operatorMethod;
+            Conversion = conversion;
+            IsExplicitInCode = isExplicitInCode;
+            ThrowsExceptionOnFailure = throwsExceptionOnFailure;
+            IsChecked = isChecked;
         }
-        /// <summary>
-        /// Value to be converted.
-        /// </summary>
+
         public abstract IOperation Operand { get; }
-        /// <summary>
-        /// Kind of conversion.
-        /// </summary>
-        public ConversionKind ConversionKind { get; }
-        /// <summary>
-        /// True if and only if the conversion is indicated explicity by a cast operation in the source code.
-        /// </summary>
-        public bool IsExplicit { get; }
-        /// <summary>
-        /// True if and only if the operation is performed by an operator method.
-        /// </summary>
-        public bool UsesOperatorMethod { get; }
-        /// <summary>
-        /// Operation method used by the operation, null if the operation does not use an operator method.
-        /// </summary>
-        public IMethodSymbol OperatorMethod { get; }
+        public CommonConversion Conversion { get; }
+        public bool IsExplicitInCode { get; }
+        public bool ThrowsExceptionOnFailure { get; }
+        public bool IsChecked { get; }
+        public abstract string LanguageName { get; }
+        public bool UsesOperatorMethod => Conversion.IsUserDefined;
+        public virtual IMethodSymbol OperatorMethod => Conversion.MethodSymbol;
         public override IEnumerable<IOperation> Children
         {
             get
@@ -1341,39 +1330,6 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
         }
     }
 
-    /// <summary>
-    /// Represents a conversion operation.
-    /// </summary>
-    internal sealed partial class ConversionExpression : BaseConversionExpression, IHasOperatorMethodExpression, IConversionExpression
-    {
-        public ConversionExpression(IOperation operand, ConversionKind conversionKind, bool isExplicit, bool usesOperatorMethod, IMethodSymbol operatorMethod, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
-            base(conversionKind, isExplicit, usesOperatorMethod, operatorMethod, syntax, type, constantValue)
-        {
-            Operand = operand;
-        }
-        /// <summary>
-        /// Value to be converted.
-        /// </summary>
-        public override IOperation Operand { get; }
-    }
-
-    /// <summary>
-    /// Represents a conversion operation.
-    /// </summary>
-    internal sealed partial class LazyConversionExpression : BaseConversionExpression, IHasOperatorMethodExpression, IConversionExpression
-    {
-        private readonly Lazy<IOperation> _lazyOperand;
-
-        public LazyConversionExpression(Lazy<IOperation> operand, ConversionKind conversionKind, bool isExplicit, bool usesOperatorMethod, IMethodSymbol operatorMethod, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(conversionKind, isExplicit, usesOperatorMethod, operatorMethod, syntax, type, constantValue)
-        {
-            _lazyOperand = operand ?? throw new System.ArgumentNullException(nameof(operand));
-        }
-        /// <summary>
-        /// Value to be converted.
-        /// </summary>
-        public override IOperation Operand => _lazyOperand.Value;
-    }
-
     /// <remarks>
     /// This interface is reserved for implementation by its associated APIs. We reserve the right to
     /// change it in the future.

src/Compilers/Core/Portable/Operations/CommonConversion.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    /// <summary>
+    /// Represents the common, language-agnostic elements of a conversion.
+    /// </summary>
+    /// <remarks>
+    /// This interface is reserved for implementation by its associated APIs. We reserve the right to
+    /// change it in the future.
+    /// </remarks>
+    public struct CommonConversion
+    {
+        internal CommonConversion(bool exists, bool isIdentity, bool isNumeric, bool isReference, bool isUserDefined, IMethodSymbol methodSymbol)
+        {
+            Exists = exists;
+            IsIdentity = isIdentity;
+            IsNumeric = isNumeric;
+            IsReference = isReference;
+            IsUserDefined = isUserDefined;
+            MethodSymbol = methodSymbol;
+        }
+
+        /// <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 reference conversion.
+        /// </summary>
+        public bool IsReference { 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; }
+    }
+}

src/Compilers/Core/Portable/Operations/IConversionExpression.cs

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Immutable;
+using System;
 
 namespace Microsoft.CodeAnalysis.Semantics
 {
@@ -17,14 +17,36 @@ public interface IConversionExpression : IHasOperatorMethodExpression
         /// Value to be converted.
         /// </summary>
         IOperation Operand { get; }
+
+#pragma warning disable RS0010 // Avoid using cref tags with a prefix
         /// <summary>
-        /// Kind of conversion.
+        /// Gets the underlying common conversion information.
         /// </summary>
-        ConversionKind ConversionKind { get; }
+        /// <remarks>
+        /// If you need conversion information that is language specific, use either
+        /// <see cref="T:Microsoft.CodeAnalysis.CSharp.IConversionExpressionExtensions.GetConversion(IConversionExpression)"/> or
+        /// <see cref="T:Microsoft.CodeAnalysis.VisualBasic.GetConversion(IConversionExpression)"/>.
+        /// </remarks>
+#pragma warning restore RS0010 // Avoid using cref tags with a prefix
+        CommonConversion Conversion { get; }
         /// <summary>
         /// True if and only if the conversion is indicated explicity by a cast operation in the source code.
         /// </summary>
-        bool IsExplicit { get; }
+        bool IsExplicitInCode { get; }
+        /// <summary>
+        /// True if the conversion will fail with a <see cref="InvalidCastException"/> at runtime if the cast fails. This is false for C#'s
+        /// <code>as</code> operator and for VB's <code>TryCast</code> operator.
+        /// </summary>
+        bool ThrowsExceptionOnFailure { get; }
+        /// <summary>
+        /// True if the conversion can fail at runtime with an overflow exception. This corresponds to C# checked and unchecked blocks.
+        /// </summary>
+        bool IsChecked { get; }
+        /// <summary>
+        /// The language that defined this conversion. Possible values are <see cref="LanguageNames.CSharp"/> and
+        /// <see cref="LanguageNames.VisualBasic"/>.
+        /// </summary>
+        string LanguageName { get; }
     }
 }
 

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -320,6 +320,13 @@ Microsoft.CodeAnalysis.Semantics.CaseKind.Pattern = 5 -> Microsoft.CodeAnalysis.
 Microsoft.CodeAnalysis.Semantics.CaseKind.Range = 3 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.Relational = 2 -> Microsoft.CodeAnalysis.Semantics.CaseKind
 Microsoft.CodeAnalysis.Semantics.CaseKind.SingleValue = 1 -> Microsoft.CodeAnalysis.Semantics.CaseKind
+Microsoft.CodeAnalysis.Semantics.CommonConversion
+Microsoft.CodeAnalysis.Semantics.CommonConversion.Exists.get -> bool
+Microsoft.CodeAnalysis.Semantics.CommonConversion.IsIdentity.get -> bool
+Microsoft.CodeAnalysis.Semantics.CommonConversion.IsNumeric.get -> bool
+Microsoft.CodeAnalysis.Semantics.CommonConversion.IsReference.get -> bool
+Microsoft.CodeAnalysis.Semantics.CommonConversion.IsUserDefined.get -> bool
+Microsoft.CodeAnalysis.Semantics.CommonConversion.MethodSymbol.get -> Microsoft.CodeAnalysis.IMethodSymbol
 Microsoft.CodeAnalysis.Semantics.ConversionKind
 Microsoft.CodeAnalysis.Semantics.ConversionKind.Basic = 3 -> Microsoft.CodeAnalysis.Semantics.ConversionKind
 Microsoft.CodeAnalysis.Semantics.ConversionKind.CSharp = 4 -> Microsoft.CodeAnalysis.Semantics.ConversionKind
@@ -387,9 +394,12 @@ Microsoft.CodeAnalysis.Semantics.IConditionalChoiceExpression.IfTrueValue.get ->
 Microsoft.CodeAnalysis.Semantics.IConstantPattern
 Microsoft.CodeAnalysis.Semantics.IConstantPattern.Value.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IConversionExpression
-Microsoft.CodeAnalysis.Semantics.IConversionExpression.ConversionKind.get -> Microsoft.CodeAnalysis.Semantics.ConversionKind
-Microsoft.CodeAnalysis.Semantics.IConversionExpression.IsExplicit.get -> bool
+Microsoft.CodeAnalysis.Semantics.IConversionExpression.Conversion.get -> Microsoft.CodeAnalysis.Semantics.CommonConversion
+Microsoft.CodeAnalysis.Semantics.IConversionExpression.IsChecked.get -> bool
+Microsoft.CodeAnalysis.Semantics.IConversionExpression.IsExplicitInCode.get -> bool
+Microsoft.CodeAnalysis.Semantics.IConversionExpression.LanguageName.get -> string
 Microsoft.CodeAnalysis.Semantics.IConversionExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation
+Microsoft.CodeAnalysis.Semantics.IConversionExpression.ThrowsExceptionOnFailure.get -> bool
 Microsoft.CodeAnalysis.Semantics.IDeclarationPattern
 Microsoft.CodeAnalysis.Semantics.IDeclarationPattern.DeclaredSymbol.get -> Microsoft.CodeAnalysis.ISymbol
 Microsoft.CodeAnalysis.Semantics.IDefaultCaseClause