Removed virtual from MethodName property, made Conversion a synthesized property.

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

@@ -8,13 +8,15 @@ 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.ToCommonConversion(), isExplicitInCode, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
+            base(isExplicitInCode, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
         {
             ConversionInternal = conversion;
         }
 
         internal Conversion ConversionInternal { get; }
 
+        public override CommonConversion Conversion => ConversionInternal.ToCommonConversion();
+
         public override string LanguageName => LanguageNames.CSharp;
     }
 

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

@@ -1296,23 +1296,22 @@ public LazyConditionalChoiceExpression(Lazy<IOperation> condition, Lazy<IOperati
     /// </summary>
     internal abstract partial class BaseConversionExpression : Operation, IHasOperatorMethodExpression, IConversionExpression
     {
-        protected BaseConversionExpression(CommonConversion conversion, bool isExplicitInCode, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        protected BaseConversionExpression(bool isExplicitInCode, bool throwsExceptionOnFailure, bool isChecked, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
                     base(OperationKind.ConversionExpression, syntax, type, constantValue)
         {
-            Conversion = conversion;
             IsExplicitInCode = isExplicitInCode;
             ThrowsExceptionOnFailure = throwsExceptionOnFailure;
             IsChecked = isChecked;
         }
 
         public abstract IOperation Operand { get; }
-        public CommonConversion Conversion { get; }
+        public abstract 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 IMethodSymbol OperatorMethod => Conversion.MethodSymbol;
         public override IEnumerable<IOperation> Children
         {
             get

src/Compilers/VisualBasic/Portable/Operations/VisualBasicConversionExpression.vb

@@ -8,13 +8,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Inherits BaseConversionExpression
 
         Protected Sub New(conversion As Conversion, isExplicitInCode As Boolean, throwsExceptionOnFailure As Boolean, isChecked As Boolean, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object))
-            MyBase.New(conversion.ToCommonConversion(), isExplicitInCode, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
+            MyBase.New(isExplicitInCode, throwsExceptionOnFailure, isChecked, syntax, type, constantValue)
 
             ConversionInternal = conversion
         End Sub
 
         Friend ReadOnly Property ConversionInternal As Conversion
 
+        Public Overrides ReadOnly Property Conversion As CommonConversion = ConversionInternal.ToCommonConversion()
+
         Public Overrides ReadOnly Property LanguageName As String = LanguageNames.VisualBasic
     End Class