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
 {
@@ -843,6 +844,21 @@ internal UserDefinedConversionAnalysis BestUserDefinedConversionAnalysis
             }
         }
 
+        /// <summary>
+        /// Creates a <seealso cref="CommonConversion"/> from this C# conversion.
+        /// </summary>
+        /// <returns>The <see cref="CommonConversion"/> that represents this conversion.</returns>
+        /// <remarks>
+        /// This is a lossy conversion; it is not possible to recover the original <see cref="Conversion"/>
+        /// from the <see cref="CommonConversion"/> struct.
+        /// </remarks>
+        public CommonConversion ToCommonConversion()
+        {
+            // The MethodSymbol of CommonConversion only refers to UserDefined conversions, not method groups
+            var methodSymbol = IsUserDefined ? MethodSymbol : null;
+            return new CommonConversion(Exists, IsIdentity, IsNumeric, IsReference, methodSymbol);
+        }
+
         /// <summary>
         /// Returns a string that represents the <see cref="Kind"/> of the conversion.
         /// </summary>

src/Compilers/CSharp/Portable/CSharpExtensions.cs

@@ -7,9 +7,8 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Roslyn.Utilities;
-using System.ComponentModel;
 using Microsoft.CodeAnalysis.Syntax;
+using Microsoft.CodeAnalysis.Semantics;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -686,6 +685,27 @@ public static TypeInfo GetSpeculativeTypeInfo(this SemanticModel semanticModel,
             }
         }
 
+        /// <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)),
+                                            nameof(conversionExpression));
+            }
+        }
+
         public static Conversion GetSpeculativeConversion(this SemanticModel semanticModel, int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption)
         {
             var csmodel = semanticModel as CSharpSemanticModel;

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} is not a valid C# conversion expression</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -485,6 +485,11 @@ internal virtual IOperation GetOperationWorker(CSharpSyntaxNode node, GetOperati
             return null;
         }
 
+        internal override T CloneOperation<T>(T operation)
+        {
+            return CSharpOperationCloner.Instance.Visit(operation);
+        }
+
         #region GetSymbolInfo
 
         /// <summary>

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

@@ -0,0 +1,43 @@
+// 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 isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue)
+        {
+            ConversionInternal = conversion;
+        }
+
+        internal Conversion ConversionInternal { get; }
+
+        public override CommonConversion Conversion => ConversionInternal.ToCommonConversion();
+    }
+
+    internal sealed partial class CSharpConversionExpression : BaseCSharpConversionExpression
+    {
+        public CSharpConversionExpression(IOperation operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue)
+        {
+            OperandImpl = operand;
+        }
+
+        public override IOperation OperandImpl { get; }
+    }
+
+    internal sealed partial class LazyCSharpConversionExpression : BaseCSharpConversionExpression
+    {
+        private readonly Lazy<IOperation> _operand;
+        public LazyCSharpConversionExpression(Lazy<IOperation> operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel,SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+            base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue)
+        {
+            _operand = operand;
+        }
+
+        public override IOperation OperandImpl => _operand.Value;
+    }
+}

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

@@ -0,0 +1,16 @@
+// 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 Microsoft.CodeAnalysis.Semantics;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal class CSharpOperationCloner : OperationCloner
+    {
+        public static OperationCloner Instance { get; } = new CSharpOperationCloner();
+
+        public override IOperation VisitConversionExpression(IConversionExpression operation, object argument)
+        {
+            return new CSharpConversionExpression(Visit(operation.Operand), operation.GetConversion(), operation.IsExplicitInCode, operation.IsTryCast, operation.IsChecked, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue);
+        }
+    }
+}

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

@@ -640,28 +640,29 @@ 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 isTryCast = false;
+                // Checked conversions only matter if the conversion is a Numeric conversion. Don't have true unless the conversion is actually numeric.
+                bool isChecked = conversion.IsNumeric && boundConversion.Checked;
                 ITypeSymbol type = boundConversion.Type;
                 Optional<object> constantValue = ConvertToOptional(boundConversion.ConstantValue);
-                return new LazyConversionExpression(operand, conversionKind, isExplicit, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue);
+                return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, 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 isTryCast = true;
+            bool isChecked = false;
             ITypeSymbol type = boundAsOperator.Type;
             Optional<object> constantValue = ConvertToOptional(boundAsOperator.ConstantValue);
-            return new LazyConversionExpression(operand, conversionKind, isExplicit, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue);
+            return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue);
         }
 
         private IIsTypeExpression CreateBoundIsOperatorOperation(BoundIsOperator boundIsOperator)

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

@@ -1 +1,3 @@
+Microsoft.CodeAnalysis.CSharp.Conversion.ToCommonConversion() -> Microsoft.CodeAnalysis.Semantics.CommonConversion
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp7_2 = 702 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(this Microsoft.CodeAnalysis.Semantics.IConversionExpression conversionExpression) -> Microsoft.CodeAnalysis.CSharp.Conversion

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests.cs

@@ -48,7 +48,8 @@ static void Test2(int y, params int[] x)
   Instance Receiver: null
   Arguments(1):
       IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'null')
-        IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: System.Int32[], Constant: null) (Syntax: 'null')
+        IConversionExpression (Implicit, TryCast: False, Unchecked) (OperationKind.ConversionExpression, Type: System.Int32[], Constant: null) (Syntax: 'null')
+          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: True, IsUserDefined: False) (MethodSymbol: null)
           Operand: ILiteralExpression (Text: null) (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'null')
         InConversion: null
         OutConversion: null");