Simplify back down now we have the fix

Author: GrahamTheCoder

CodeConverter/CSharp/BinaryExpressionConverter.cs

@@ -1,4 +1,4 @@
-using ICSharpCode.CodeConverter.Util.FromRoslyn;
+using ICSharpCode.CodeConverter.Util.FromRoslyn;
 
 namespace ICSharpCode.CodeConverter.CSharp;
 
@@ -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

@@ -1,4 +1,4 @@
-using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.VisualBasic.CompilerServices;
 using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using SyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
@@ -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), rhs);
                 return notted
                     ? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, equalityCheck)
                     : equalityCheck;
@@ -80,14 +80,9 @@ private static VBSyntax.ExpressionSyntax ArgComparedToNull(VBSyntax.BinaryExpres
             return null;
         }
 
-        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);
-        }
+        private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg) =>
+            await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
+            ?? await binaryExpressionArg.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
 
         private async Task<ExpressionSyntax> ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(SyntaxNode node)
         {
@@ -127,17 +122,6 @@ 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>
         private static async Task<ExpressionSyntax> ConvertToDecimalBinaryOperatorAsync(VBSyntax.BinaryExpressionSyntax node, KnownMethod member) =>
             default;

CodeConverter/CSharp/NameExpressionNodeVisitor.cs

@@ -162,10 +162,6 @@ public async Task<CSharpSyntaxNode> ConvertQualifiedNameAsync(VBasic.Syntax.Qual
     /// <remarks>PERF: This is a hot code path, try to avoid using things like GetOperation except where needed.</remarks>
     public async Task<CSharpSyntaxNode> ConvertIdentifierNameAsync(VBasic.Syntax.IdentifierNameSyntax node)
     {
-        if (node.Identifier.IsMissing && node.Parent is VBasic.Syntax.TypeArgumentListSyntax) {
-            return SyntaxFactory.OmittedTypeArgument();
-        }
-
         var identifier = SyntaxFactory.IdentifierName(CommonConversions.ConvertIdentifier(node.Identifier, node.GetAncestor<VBasic.Syntax.AttributeSyntax>() != null));
 
         bool requiresQualification = !node.Parent.IsKind(VBasic.SyntaxKind.SimpleMemberAccessExpression, VBasic.SyntaxKind.QualifiedName, VBasic.SyntaxKind.NameColonEquals, VBasic.SyntaxKind.ImportsStatement, VBasic.SyntaxKind.NamespaceStatement, VBasic.SyntaxKind.NamedFieldInitializer) ||
@@ -622,13 +618,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,9 +49,6 @@ 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))) {
-            return csNode;
-        }
 
         var conversionKind = AnalyzeConversion(vbNode, defaultToCast, isConst, forceSourceType, forceTargetType);
         csNode = addParenthesisIfNeeded && conversionKind is TypeConversionKind.DestructiveCast or TypeConversionKind.NonDestructiveCast
@@ -62,9 +59,6 @@ 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))) {
-            return (csNode, false);
-        }
         var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);
         bool resultConst = false;
 
@@ -148,9 +142,6 @@ 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))) {
-            return TypeConversionKind.NonDestructiveCast;
-        }
         var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);
 
         if (vbConvertedType is null)

CodeConverter/CSharp/VisualBasicEqualityComparison.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable enable
 using System.Globalization;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.VisualBasic.CompilerServices;
@@ -77,22 +77,6 @@ public RequiredType GetObjectEqualityType(params TypeInfo[] typeInfos)
     {
         bool requiresVbEqualityCheck = typeInfos.Any(t => t.Type?.SpecialType == SpecialType.System_Object);
 
-        if (typeInfos.Any(t => t.Type?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error && t.ConvertedType?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)) {
-             return RequiredType.None;
-        }
-        if (requiresVbEqualityCheck) {
-            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;
-            }
-        }
-
         if (typeInfos.All(
                 t => t.Type == null || t.Type.SpecialType == SpecialType.System_String ||
                      t.Type.IsArrayOf(SpecialType.System_Char) ) ) {