Simplify back down now we have the fix

Author: GrahamTheCoder

CodeConverter/CSharp/BinaryExpressionConverter.cs

@@ -101,19 +101,6 @@ private async Task<CSharpSyntaxNode> ConvertBinaryExpressionAsync(VBasic.Syntax.
         lhs = omitConversion ? lhs : CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Left, lhs, forceTargetType: forceLhsTargetType);
         rhs = omitConversion || omitRightConversion ? rhs : CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, rhs);
 
-        if (node.Right is VBSyntax.GetTypeExpressionSyntax getTypeExpr) {
-            var isUnboundGeneric = getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing));
-            if (isUnboundGeneric) {
-                rhs = await node.Right.AcceptAsync<CSSyntax.ExpressionSyntax>(TriviaConvertingExpressionVisitor);
-            }
-        }
-        if (node.Left is VBSyntax.GetTypeExpressionSyntax getTypeExprLeft) {
-            var isUnboundGeneric = getTypeExprLeft.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing));
-            if (isUnboundGeneric) {
-                lhs = await node.Left.AcceptAsync<CSSyntax.ExpressionSyntax>(TriviaConvertingExpressionVisitor);
-            }
-        }
-
         var kind = VBasic.VisualBasicExtensions.Kind(node).ConvertToken();
         var op = CS.SyntaxFactory.Token(CSharpUtil.GetExpressionOperatorTokenKind(kind));
 

CodeConverter/CSharp/BuiltInVisualBasicOperatorSubstitutions.cs

@@ -58,7 +58,7 @@ public async Task<ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsy
 
                 var equalityCheck = new KnownMethod(nameof(System), nameof(Object), nameof(object.ReferenceEquals))
                     .Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives,
-                        ConvertToIfNecessary(node.Left, lhs, SpecialType.System_Object), ConvertToIfNecessary(node.Right, rhs, SpecialType.System_Object));
+                        ConvertTo(node.Left, lhs, SpecialType.System_Object), ConvertTo(node.Right, rhs, SpecialType.System_Object));
                 return notted
                     ? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, equalityCheck)
                     : equalityCheck;
@@ -82,9 +82,6 @@ private static VBSyntax.ExpressionSyntax ArgComparedToNull(VBSyntax.BinaryExpres
 
         private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg)
         {
-            if (binaryExpressionArg is VBSyntax.GetTypeExpressionSyntax getTypeExpr && getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing))) {
-                return await getTypeExpr.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
-            }
             return await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
                 ?? await binaryExpressionArg.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
         }
@@ -127,18 +124,7 @@ private ExpressionSyntax ConvertTo(VBSyntax.ExpressionSyntax vbNode, ExpressionS
             return _typeConversionAnalyzer.AddExplicitConversion(vbNode, csNode, forceTargetType: _semanticModel.Compilation.GetSpecialType(targetType));
         }
 
-        private ExpressionSyntax ConvertToIfNecessary(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, SpecialType targetType)
-        {
-            if (vbNode is VBSyntax.GetTypeExpressionSyntax getTypeExpr && getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing))) {
-                return csNode;
-            }
-            if (csNode is TypeOfExpressionSyntax typeOfExpr && typeOfExpr.Type is GenericNameSyntax gen && gen.TypeArgumentList.Arguments.Any(a => a is OmittedTypeArgumentSyntax)) {
-                return csNode;
-            }
-            return ConvertTo(vbNode, csNode, targetType);
-        }
-
-        /// <remarks>No need to implement these since this is only called for things that are already decimal and hence will resolve operator in C#</remarks>
+/// <remarks>No need to implement these since this is only called for things that are already decimal and hence will resolve operator in C#</remarks>
         private static async Task<ExpressionSyntax> ConvertToDecimalBinaryOperatorAsync(VBSyntax.BinaryExpressionSyntax node, KnownMethod member) =>
             default;
 

CodeConverter/CSharp/NameExpressionNodeVisitor.cs

@@ -622,13 +622,7 @@ private ITypeSymbol[] GetOrNullAllTypeArgsIncludingInferred(IMethodSymbol vbMeth
 
     private async Task<TypeArgumentListSyntax> ConvertTypeArgumentListAsync(VBSyntax.GenericNameSyntax node)
     {
-        var args = await node.TypeArgumentList.Arguments.SelectAsync(async a => {
-            if (a is VBasic.Syntax.IdentifierNameSyntax id && id.Identifier.IsMissing) {
-                return CS.SyntaxFactory.OmittedTypeArgument();
-            }
-            return await a.AcceptAsync<TypeSyntax>(TriviaConvertingExpressionVisitor);
-        });
-        return CS.SyntaxFactory.TypeArgumentList(CS.SyntaxFactory.SeparatedList<TypeSyntax>(args));
+        return await node.TypeArgumentList.AcceptAsync<TypeArgumentListSyntax>(TriviaConvertingExpressionVisitor);
     }
 
     private CSharpSyntaxNode AddEmptyArgumentListIfImplicit(SyntaxNode node, ExpressionSyntax id)

CodeConverter/CSharp/TypeConversionAnalyzer.cs

@@ -49,7 +49,7 @@ public TypeConversionAnalyzer(SemanticModel semanticModel, CSharpCompilation csC
     public ExpressionSyntax AddExplicitConversion(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, bool addParenthesisIfNeeded = true, bool defaultToCast = false, bool isConst = false, ITypeSymbol forceSourceType = null, ITypeSymbol forceTargetType = null)
     {
         if (csNode == null) return null;
-        if (vbNode is VBSyntax.GetTypeExpressionSyntax getTypeExpr && getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing))) {
+        if (vbNode.IsUnboundGenericGetType()) {
             return csNode;
         }
 
@@ -62,7 +62,7 @@ public ExpressionSyntax AddExplicitConversion(VBSyntax.ExpressionSyntax vbNode,
 
     public (ExpressionSyntax Expr, bool IsConst) AddExplicitConversion(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded = false, bool requiresConst = false, ITypeSymbol forceSourceType = null, ITypeSymbol forceTargetType = null)
     {
-        if (vbNode is VBSyntax.GetTypeExpressionSyntax getTypeExpr2 && getTypeExpr2.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing))) {
+        if (vbNode.IsUnboundGenericGetType()) {
             return (csNode, false);
         }
         var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);
@@ -148,7 +148,7 @@ private ExpressionSyntax CreateCast(ExpressionSyntax csNode, ITypeSymbol vbConve
 
     public TypeConversionKind AnalyzeConversion(VBSyntax.ExpressionSyntax vbNode, bool alwaysExplicit = false, bool isConst = false, ITypeSymbol forceSourceType = null, ITypeSymbol forceTargetType = null)
     {
-        if (vbNode is VBSyntax.GetTypeExpressionSyntax getTypeExpr && getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing))) {
+        if (vbNode.IsUnboundGenericGetType()) {
             return TypeConversionKind.NonDestructiveCast;
         }
         var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);

CodeConverter/CSharp/VbSyntaxNodeExtensions.cs

@@ -31,6 +31,15 @@ public static bool AlwaysHasBooleanTypeInCSharp(this VBSyntax.ExpressionSyntax v
                parent is VBSyntax.WhereClauseSyntax;
     }
 
+    /// <summary>
+    /// Returns true if the node is a GetType expression with an unbound generic type argument,
+    /// e.g. <c>GetType(Nullable(Of))</c> in VB, which maps to <c>typeof(Nullable&lt;&gt;)</c> in C#.
+    /// </summary>
+    public static bool IsUnboundGenericGetType(this VBSyntax.ExpressionSyntax node) =>
+        node is VBSyntax.GetTypeExpressionSyntax getTypeExpr &&
+        getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>()
+            .Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing));
+
     public static TokenContext GetMemberContext(this VBSyntax.StatementSyntax member)
     {
         var parentType = member.GetAncestorOrThis<VBSyntax.TypeBlockSyntax>();

CodeConverter/CSharp/VisualBasicEqualityComparison.cs

@@ -84,9 +84,6 @@ public RequiredType GetObjectEqualityType(params TypeInfo[] typeInfos)
             if (typeInfos.Any(t => t.Type?.TypeKind == TypeKind.Error && t.ConvertedType?.SpecialType == SpecialType.None)) {
                  return RequiredType.None;
             }
-        }
-
-        if (requiresVbEqualityCheck) {
             if (typeInfos.Any(t => t.Type?.TypeKind == TypeKind.Error && t.Type.Name == "Nullable")) {
                  // VB considers GetType(Nullable(Of)) as IErrorTypeSymbol and it falls back to object, avoid equality check
                  return RequiredType.None;