Skip to content

Commit 8e57b67

Browse files
GrahamTheCoderGrahamTheCoder
committed
Simplify back down now we have the fix
1 parent 78a1610 commit 8e57b67

File tree

5 files changed

+5
-69
lines changed

5 files changed

+5
-69
lines changed

‎CodeConverter/CSharp/BinaryExpressionConverter.cs‎

Lines changed: 0 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -101,19 +101,6 @@ private async Task<CSharpSyntaxNode> ConvertBinaryExpressionAsync(VBasic.Syntax.
101101
lhs = omitConversion ? lhs : CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Left, lhs, forceTargetType: forceLhsTargetType);
102102
rhs = omitConversion || omitRightConversion ? rhs : CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, rhs);
103103

104-
if (node.Right is VBSyntax.GetTypeExpressionSyntax getTypeExpr) {
105-
var isUnboundGeneric = getTypeExpr.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing));
106-
if (isUnboundGeneric) {
107-
rhs = await node.Right.AcceptAsync<CSSyntax.ExpressionSyntax>(TriviaConvertingExpressionVisitor);
108-
}
109-
}
110-
if (node.Left is VBSyntax.GetTypeExpressionSyntax getTypeExprLeft) {
111-
var isUnboundGeneric = getTypeExprLeft.Type.DescendantNodesAndSelf().OfType<VBSyntax.TypeArgumentListSyntax>().Any(t => t.Arguments.Any(a => a is VBSyntax.IdentifierNameSyntax id && id.Identifier.IsMissing));
112-
if (isUnboundGeneric) {
113-
lhs = await node.Left.AcceptAsync<CSSyntax.ExpressionSyntax>(TriviaConvertingExpressionVisitor);
114-
}
115-
}
116-
117104
var kind = VBasic.VisualBasicExtensions.Kind(node).ConvertToken();
118105
var op = CS.SyntaxFactory.Token(CSharpUtil.GetExpressionOperatorTokenKind(kind));
119106

‎CodeConverter/CSharp/BuiltInVisualBasicOperatorSubstitutions.cs‎

Lines changed: 4 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ public async Task<ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsy
5858

5959
var equalityCheck = new KnownMethod(nameof(System), nameof(Object), nameof(object.ReferenceEquals))
6060
.Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives,
61-
ConvertToIfNecessary(node.Left, lhs, SpecialType.System_Object), ConvertToIfNecessary(node.Right, rhs, SpecialType.System_Object));
61+
ConvertTo(node.Left, lhs, SpecialType.System_Object), rhs);
6262
return notted
6363
? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, equalityCheck)
6464
: equalityCheck;
@@ -80,14 +80,9 @@ private static VBSyntax.ExpressionSyntax ArgComparedToNull(VBSyntax.BinaryExpres
8080
return null;
8181
}
8282

83-
private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg)
84-
{
85-
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))) {
86-
return await getTypeExpr.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
87-
}
88-
return await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
89-
?? await binaryExpressionArg.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
90-
}
83+
private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg) =>
84+
await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
85+
?? await binaryExpressionArg.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
9186

9287
private async Task<ExpressionSyntax> ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(SyntaxNode node)
9388
{
@@ -127,17 +122,6 @@ private ExpressionSyntax ConvertTo(VBSyntax.ExpressionSyntax vbNode, ExpressionS
127122
return _typeConversionAnalyzer.AddExplicitConversion(vbNode, csNode, forceTargetType: _semanticModel.Compilation.GetSpecialType(targetType));
128123
}
129124

130-
private ExpressionSyntax ConvertToIfNecessary(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, SpecialType targetType)
131-
{
132-
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))) {
133-
return csNode;
134-
}
135-
if (csNode is TypeOfExpressionSyntax typeOfExpr && typeOfExpr.Type is GenericNameSyntax gen && gen.TypeArgumentList.Arguments.Any(a => a is OmittedTypeArgumentSyntax)) {
136-
return csNode;
137-
}
138-
return ConvertTo(vbNode, csNode, targetType);
139-
}
140-
141125
/// <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>
142126
private static async Task<ExpressionSyntax> ConvertToDecimalBinaryOperatorAsync(VBSyntax.BinaryExpressionSyntax node, KnownMethod member) =>
143127
default;

‎CodeConverter/CSharp/NameExpressionNodeVisitor.cs‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -162,10 +162,6 @@ public async Task<CSharpSyntaxNode> ConvertQualifiedNameAsync(VBasic.Syntax.Qual
162162
/// <remarks>PERF: This is a hot code path, try to avoid using things like GetOperation except where needed.</remarks>
163163
public async Task<CSharpSyntaxNode> ConvertIdentifierNameAsync(VBasic.Syntax.IdentifierNameSyntax node)
164164
{
165-
if (node.Identifier.IsMissing && node.Parent is VBasic.Syntax.TypeArgumentListSyntax) {
166-
return SyntaxFactory.OmittedTypeArgument();
167-
}
168-
169165
var identifier = SyntaxFactory.IdentifierName(CommonConversions.ConvertIdentifier(node.Identifier, node.GetAncestor<VBasic.Syntax.AttributeSyntax>() != null));
170166

171167
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
622618

623619
private async Task<TypeArgumentListSyntax> ConvertTypeArgumentListAsync(VBSyntax.GenericNameSyntax node)
624620
{
625-
var args = await node.TypeArgumentList.Arguments.SelectAsync(async a => {
626-
if (a is VBasic.Syntax.IdentifierNameSyntax id && id.Identifier.IsMissing) {
627-
return CS.SyntaxFactory.OmittedTypeArgument();
628-
}
629-
return await a.AcceptAsync<TypeSyntax>(TriviaConvertingExpressionVisitor);
630-
});
631-
return CS.SyntaxFactory.TypeArgumentList(CS.SyntaxFactory.SeparatedList<TypeSyntax>(args));
621+
return await node.TypeArgumentList.AcceptAsync<TypeArgumentListSyntax>(TriviaConvertingExpressionVisitor);
632622
}
633623

634624
private CSharpSyntaxNode AddEmptyArgumentListIfImplicit(SyntaxNode node, ExpressionSyntax id)

‎CodeConverter/CSharp/TypeConversionAnalyzer.cs‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,6 @@ public TypeConversionAnalyzer(SemanticModel semanticModel, CSharpCompilation csC
4949
public ExpressionSyntax AddExplicitConversion(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, bool addParenthesisIfNeeded = true, bool defaultToCast = false, bool isConst = false, ITypeSymbol forceSourceType = null, ITypeSymbol forceTargetType = null)
5050
{
5151
if (csNode == null) return null;
52-
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))) {
53-
return csNode;
54-
}
5552

5653
var conversionKind = AnalyzeConversion(vbNode, defaultToCast, isConst, forceSourceType, forceTargetType);
5754
csNode = addParenthesisIfNeeded && conversionKind is TypeConversionKind.DestructiveCast or TypeConversionKind.NonDestructiveCast
@@ -62,9 +59,6 @@ public ExpressionSyntax AddExplicitConversion(VBSyntax.ExpressionSyntax vbNode,
6259

6360
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)
6461
{
65-
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))) {
66-
return (csNode, false);
67-
}
6862
var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);
6963
bool resultConst = false;
7064

@@ -148,9 +142,6 @@ private ExpressionSyntax CreateCast(ExpressionSyntax csNode, ITypeSymbol vbConve
148142

149143
public TypeConversionKind AnalyzeConversion(VBSyntax.ExpressionSyntax vbNode, bool alwaysExplicit = false, bool isConst = false, ITypeSymbol forceSourceType = null, ITypeSymbol forceTargetType = null)
150144
{
151-
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))) {
152-
return TypeConversionKind.NonDestructiveCast;
153-
}
154145
var (vbType, vbConvertedType) = GetTypeInfo(vbNode, forceSourceType, forceTargetType);
155146

156147
if (vbConvertedType is null)

‎CodeConverter/CSharp/VisualBasicEqualityComparison.cs‎

Lines changed: 0 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -77,22 +77,6 @@ public RequiredType GetObjectEqualityType(params TypeInfo[] typeInfos)
7777
{
7878
bool requiresVbEqualityCheck = typeInfos.Any(t => t.Type?.SpecialType == SpecialType.System_Object);
7979

80-
if (typeInfos.Any(t => t.Type?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error && t.ConvertedType?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)) {
81-
return RequiredType.None;
82-
}
83-
if (requiresVbEqualityCheck) {
84-
if (typeInfos.Any(t => t.Type?.TypeKind == TypeKind.Error && t.ConvertedType?.SpecialType == SpecialType.None)) {
85-
return RequiredType.None;
86-
}
87-
}
88-
89-
if (requiresVbEqualityCheck) {
90-
if (typeInfos.Any(t => t.Type?.TypeKind == TypeKind.Error && t.Type.Name == "Nullable")) {
91-
// VB considers GetType(Nullable(Of)) as IErrorTypeSymbol and it falls back to object, avoid equality check
92-
return RequiredType.None;
93-
}
94-
}
95-
9680
if (typeInfos.All(
9781
t => t.Type == null || t.Type.SpecialType == SpecialType.System_String ||
9882
t.Type.IsArrayOf(SpecialType.System_Char) ) ) {

0 commit comments

Comments
 (0)