Merge remote-tracking branch 'origin/master'

# Conflicts:
#	Tests/CSharp/MultiFileSolutionAndProjectTests.cs

Author: GrahamTheCoder

.editorconfig

@@ -149,3 +149,6 @@ dotnet_diagnostic.RCS1123.severity = none
 
 # Default severity for analyzer diagnostics with category 'Performance' - turn this up to warn when looking for performance issues
 dotnet_analyzer_diagnostic.category-Performance.severity = suggestion
+
+# CC0097: You have missing/unexistent parameters in Xml Docs
+dotnet_diagnostic.CC0097.severity = none

.github/workflows/dotnet.yml

@@ -10,7 +10,7 @@ jobs:
  build:
     runs-on: windows-latest
     env:
-      BuildVersion: '8.2.3'
+      BuildVersion: '8.2.4'
       BuildPlatform: Any CPU
       BuildTarget: Release
     steps:

CHANGELOG.md

@@ -10,24 +10,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ### VB -> C#
 
+* Prevent overrides and overloads appearing on the same property [#681](https://github.com/icsharpcode/CodeConverter/issues/681)
+* Convert `Select x = ` into `let x = ` within Linq [#717](https://github.com/icsharpcode/CodeConverter/issues/717)
 
 ### C# -> VB
 
 
-## [8.2.3] - 2021-04-04
+## [8.2.4] - 2021-05-04
 
 ### Command line
+
 * The --Core-Only flag no longer requires a value [#704](https://github.com/icsharpcode/CodeConverter/issues/704)
 
 
 ### VB -> C#
+
 * Deal with NullReferenceException caused by Nothing literal [#707](https://github.com/icsharpcode/CodeConverter/issues/707)
 * Include text of region which can't be converted
 * Convert region names
 * All handlers from multi-line handles syntax now converted [#701](https://github.com/icsharpcode/CodeConverter/issues/701)
 * Implicilty typed inherited events no longer create extra delegates [#700](https://github.com/icsharpcode/CodeConverter/issues/700)
 * Keep optional parameters for parameterized properties [#642](https://github.com/icsharpcode/CodeConverter/issues/642)
 * Maintain leading whitespace in comments [#711](https://github.com/icsharpcode/CodeConverter/issues/711)
+* Avoid XmlException when referencing certain nuget packages [#714](https://github.com/icsharpcode/CodeConverter/issues/714)
+* Use explicit type as default for array creation [#713](https://github.com/icsharpcode/CodeConverter/issues/713)
 
 ### C# -> VB
 

CodeConverter/CSharp/BuiltInVisualBasicOperatorSubstitutions.cs

@@ -17,6 +17,7 @@
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.VisualBasic;
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
@@ -92,11 +93,9 @@ private static VBSyntax.ExpressionSyntax ArgComparedToNull(VBSyntax.BinaryExpres
                 return null;
             }
 
-            private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg)
-            {
-                return (ExpressionSyntax) (await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
-                                           ?? await binaryExpressionArg.AcceptAsync(_triviaConvertingVisitor));
-            }
+            private async Task<ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg) =>
+                await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
+                ?? await binaryExpressionArg.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
 
             private async Task<ExpressionSyntax> ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(SyntaxNode node)
             {
@@ -106,8 +105,8 @@ private async Task<ExpressionSyntax> ConvertMyGroupCollectionPropertyGetWithUnde
                         return await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(co.Operand.Syntax);
                     case IPropertyReferenceOperation pro when pro.Property.IsMyGroupCollectionProperty():
                         var associatedField = pro.Property.GetAssociatedField();
-                        var propertyReferenceOperation = ((IPropertyReferenceOperation)pro.Instance);
-                        var qualification = await propertyReferenceOperation.Syntax.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
+                        var propertyReferenceSyntax = (VisualBasicSyntaxNode)((IPropertyReferenceOperation)pro.Instance).Syntax;
+                        var qualification = await propertyReferenceSyntax.AcceptAsync<ExpressionSyntax>(_triviaConvertingVisitor);
                         return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, qualification, SyntaxFactory.IdentifierName(associatedField.Name));
                     default:
                         return null;

CodeConverter/CSharp/CommentConvertingVisitorWrapper.cs

@@ -18,17 +18,18 @@ internal class CommentConvertingVisitorWrapper
     {
         private readonly VBasic.VisualBasicSyntaxVisitor<Task<CS.CSharpSyntaxNode>> _wrappedVisitor;
         private readonly SyntaxTree _syntaxTree;
+        private static readonly CSSyntax.LiteralExpressionSyntax _dummyLiteral = ValidSyntaxFactory.DefaultExpression;
+        private static readonly CSSyntax.StatementSyntax _dummyStatement = CS.SyntaxFactory.EmptyStatement();
+        private static readonly CSSyntax.CompilationUnitSyntax _dummyCompilationUnit = CS.SyntaxFactory.CompilationUnit();
 
         public CommentConvertingVisitorWrapper(VisualBasicSyntaxVisitor<Task<CSharpSyntaxNode>> wrappedVisitor, SyntaxTree syntaxTree)
         {
             _wrappedVisitor = wrappedVisitor;
             _syntaxTree = syntaxTree;
         }
 
-        public async Task<T> AcceptAsync<T>(SyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
-        {
-            return await ConvertHandledAsync<T>(vbNode, sourceTriviaMap);
-        }
+        public async Task<T> AcceptAsync<T>(VisualBasicSyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode =>
+            await ConvertHandledAsync<T>(vbNode, sourceTriviaMap);
 
         public async Task<SeparatedSyntaxList<TOut>> AcceptAsync<TIn, TOut>(SeparatedSyntaxList<TIn> vbNodes, SourceTriviaMapKind sourceTriviaMap) where TIn : VBasic.VisualBasicSyntaxNode where TOut : CS.CSharpSyntaxNode
         {
@@ -41,7 +42,7 @@ public async Task<SeparatedSyntaxList<TOut>> AcceptAsync<TIn, TOut>(SeparatedSyn
             return CS.SyntaxFactory.SeparatedList(convertedNodes, convertedSeparators);
         }
 
-        private async Task<T> ConvertHandledAsync<T>(SyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
+        private async Task<T> ConvertHandledAsync<T>(VisualBasicSyntaxNode vbNode, SourceTriviaMapKind sourceTriviaMap) where T : CS.CSharpSyntaxNode
         {
             try {
                 var converted = (T)await _wrappedVisitor.Visit(vbNode);
@@ -50,9 +51,12 @@ private async Task<T> ConvertHandledAsync<T>(SyntaxNode vbNode, SourceTriviaMapK
                     : sourceTriviaMap == SourceTriviaMapKind.SubNodesOnly
                         ? converted
                         : WithSourceMapping(vbNode, converted);
-            } catch (Exception e) when (typeof(T).IsAssignableFrom(typeof(CSSyntax.EmptyStatementSyntax))) {
-                var dummyStatement = (T)(object)CS.SyntaxFactory.EmptyStatement();
-                return dummyStatement.WithCsTrailingErrorComment((VBasic.VisualBasicSyntaxNode)vbNode, e);
+            } catch (Exception e) when (_dummyLiteral is T dummy) {
+                return dummy.WithCsTrailingErrorComment(vbNode, e);
+            } catch (Exception e) when (_dummyStatement is T dummy) {
+                return dummy.WithCsTrailingErrorComment(vbNode, e);
+            } catch (Exception e) when (_dummyCompilationUnit is T dummy) {
+                return dummy.WithCsTrailingErrorComment(vbNode, e);
             } catch (Exception e) when (!(e is ExceptionWithNodeInformation)) {
                 throw e.WithNodeInformation(vbNode);
             }

CodeConverter/CSharp/CommonConversions.cs

@@ -1,16 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.Shared;
 using ICSharpCode.CodeConverter.Util;
-using ICSharpCode.CodeConverter.Util.FromRoslyn;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Operations;
@@ -64,11 +61,11 @@ public CommonConversions(Document document, SemanticModel semanticModel,
             WinformsConversions = new WinformsConversions(typeContext);
         }
 
-        public async Task<(IReadOnlyCollection<(VariableDeclarationSyntax Decl, ITypeSymbol Type)> Variables, IReadOnlyCollection<CSharpSyntaxNode> Methods)> SplitVariableDeclarationsAsync(
+        public async Task<(IReadOnlyCollection<(CSSyntax.VariableDeclarationSyntax Decl, ITypeSymbol Type)> Variables, IReadOnlyCollection<CSharpSyntaxNode> Methods)> SplitVariableDeclarationsAsync(
             VariableDeclaratorSyntax declarator, HashSet<ILocalSymbol> symbolsToSkip = null, bool preferExplicitType = false)
         {
             var vbInitValue = GetInitializerToConvert(declarator);
-            var initializerOrMethodDecl = await vbInitValue.AcceptAsync(TriviaConvertingExpressionVisitor);
+            var initializerOrMethodDecl = await vbInitValue.AcceptAsync<CSharpSyntaxNode>(TriviaConvertingExpressionVisitor);
             var vbInitializerTypeInfo = vbInitValue != null ? _semanticModel.GetTypeInfo(vbInitValue) : default(TypeInfo?);
             var vbInitializerType = vbInitValue != null ? vbInitializerTypeInfo.Value.Type : default(ITypeSymbol);
 
@@ -82,7 +79,7 @@ public CommonConversions(Document document, SemanticModel semanticModel,
                 requireExplicitTypeForAll |= vbInitIsNothingLiteral || isAnonymousFunction;
             }
 
-            var csVars = new Dictionary<string, (VariableDeclarationSyntax Decl, ITypeSymbol Type)>();
+            var csVars = new Dictionary<string, (CSSyntax.VariableDeclarationSyntax Decl, ITypeSymbol Type)>();
             var csMethods = new List<CSharpSyntaxNode>();
 
             foreach (var name in declarator.Names) {
@@ -124,7 +121,7 @@ public bool ShouldPreferExplicitType(VBSyntax.ExpressionSyntax exp,
             return shouldPreferExplicitType;
         }
 
-        private async Task<EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntaxAsync(
+        private async Task<CSSyntax.EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntaxAsync(
             VariableDeclaratorSyntax vbDeclarator, VBSyntax.ModifiedIdentifierSyntax vbName,
             VBSyntax.ExpressionSyntax vbInitValue,
             ITypeSymbol declaredSymbolType,
@@ -136,7 +133,7 @@ private async Task<EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntaxAsync(
             bool declaredConst = declaredSymbol is IFieldSymbol fieldSymbol && fieldSymbol.IsConst ||
                                  declaredSymbol is ILocalSymbol localSymbol && localSymbol.IsConst;
 
-            EqualsValueClauseSyntax equalsValueClauseSyntax;
+            CSSyntax.EqualsValueClauseSyntax equalsValueClauseSyntax;
             if (await GetInitializerFromNameAndTypeAsync(declaredSymbolType, vbName, initializerOrMethodDecl) is ExpressionSyntax
                 adjustedInitializerExpr)
             {
@@ -180,9 +177,9 @@ public static string GetInitialValueFunctionName(VBSyntax.ModifiedIdentifierSynt
             return "initial" + vbName.Identifier.ValueText.ToPascalCase();
         }
 
-        private VariableDeclarationSyntax CreateVariableDeclaration(VariableDeclaratorSyntax vbDeclarator, bool preferExplicitType,
+        private CSSyntax.VariableDeclarationSyntax CreateVariableDeclaration(VariableDeclaratorSyntax vbDeclarator, bool preferExplicitType,
             bool requireExplicitTypeForAll, ITypeSymbol vbInitializerType, ITypeSymbol declaredSymbolType,
-            EqualsValueClauseSyntax equalsValueClauseSyntax, IMethodSymbol initSymbol, CSSyntax.VariableDeclaratorSyntax v)
+            CSSyntax.EqualsValueClauseSyntax equalsValueClauseSyntax, IMethodSymbol initSymbol, CSSyntax.VariableDeclaratorSyntax v)
         {
             var requireExplicitType = requireExplicitTypeForAll ||
                                       vbInitializerType != null && !Equals(declaredSymbolType, vbInitializerType);
@@ -257,7 +254,7 @@ private async Task<CSharpSyntaxNode> GetInitializerFromNameAndTypeAsync(ITypeSym
                 var arrayTypeSyntax = ((ArrayTypeSyntax)GetTypeSyntax(typeSymbol)).WithRankSpecifiers(rankSpecifiersWithSizes);
                 if (rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).Any(e => !e.IsKind(CSSyntaxKind.OmittedArraySizeExpression))) {
                     initializer = SyntaxFactory.ArrayCreationExpression(arrayTypeSyntax);
-                } else if (initializer is ImplicitArrayCreationExpressionSyntax iaces && iaces.Initializer != null) {
+                } else if (initializer is CSSyntax.ImplicitArrayCreationExpressionSyntax iaces && iaces.Initializer != null) {
                     initializer = SyntaxFactory.ArrayCreationExpression(arrayTypeSyntax, iaces.Initializer);
                 }
             }
@@ -274,7 +271,7 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
             if (id.SyntaxTree == _semanticModel.SyntaxTree) {
                 var idSymbol = _semanticModel.GetSymbolInfo(id.Parent).Symbol ?? _semanticModel.GetDeclaredSymbol(id.Parent);
                 if (idSymbol != null && !String.IsNullOrWhiteSpace(idSymbol.Name)) {
-                    text = WithDeclarationName(id, idSymbol, text);
+                    text = WithDeclarationName(id, idSymbol, text, _typeContext.AssembliesBeingConverted);
                     var normalizedText = text.WithHalfWidthLatinCharacters();
                     if (idSymbol.IsConstructor() && isAttribute) {
                         text = idSymbol.ContainingType.Name;
@@ -307,10 +304,32 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
         /// <seealso cref="DeclarationNodeVisitor.WithDeclarationNameCasingAsync(VBSyntax.NamespaceBlockSyntax, ISymbol)"/>
         /// <seealso cref="CommonConversions.WithDeclarationNameCasing(TypeSyntax, ITypeSymbol)"/>
         /// </summary>
-        private static string WithDeclarationName(SyntaxToken id, ISymbol idSymbol, string text)
+        private static string WithDeclarationName(SyntaxToken id, ISymbol idSymbol, string text, IEnumerable<IAssemblySymbol> assembliesBeingConverted)
         {
             //This also covers the case when the name is different (in VB you can have method X implements IFoo.Y), but doesn't resolve any resulting name clashes
-            var baseSymbol = idSymbol.IsKind(SymbolKind.Method) || idSymbol.IsKind(SymbolKind.Property) ? idSymbol.FollowProperty(s => s.BaseMember()).Last() : idSymbol;
+            var assemblyIdentities = assembliesBeingConverted.Select(t => t.Identity);
+            ISymbol baseSymbol = default;
+            var containingType = idSymbol.ContainingType;
+
+            if (idSymbol.IsKind(SymbolKind.Method) || idSymbol.IsKind(SymbolKind.Property)) 
+            {
+                var possibleSymbols = idSymbol.FollowProperty(s => s.BaseMember());
+                foreach (var possibleSymbol in possibleSymbols)
+                {
+                    if (!assemblyIdentities.Contains(possibleSymbol.ContainingAssembly.Identity) && possibleSymbol.ContainingType.Equals(containingType)) 
+                    {
+                        baseSymbol = possibleSymbol;
+                        break;
+                    }
+
+                    baseSymbol = possibleSymbol;
+                }
+            } 
+            else 
+            {
+                baseSymbol = idSymbol;
+            }
+
             bool isDeclaration = baseSymbol.Locations.Any(l => l.SourceSpan == id.Span);
             bool isPartial = baseSymbol.IsPartialClassDefinition() || baseSymbol.IsPartialMethodDefinition() ||
                              baseSymbol.IsPartialMethodImplementation();
@@ -349,11 +368,13 @@ public SyntaxTokenList ConvertModifiers(SyntaxNode node, IReadOnlyCollection<Syn
 
         private static bool? RequiresNewKeyword(ISymbol declaredSymbol)
         {
-            if (!(declaredSymbol is IMethodSymbol methodSymbol)) return null;
-            if (declaredSymbol.IsOverride ) return false;
-            var methodSignature = methodSymbol.GetUnqualifiedMethodSignature(true);
-            return declaredSymbol.ContainingType.FollowProperty(s => s.BaseType).Skip(1).Any(t => t.GetMembers()
-                .Any(s => s.Name == declaredSymbol.Name && s is IMethodSymbol m && m.GetUnqualifiedMethodSignature(true) == methodSignature));
+            if (declaredSymbol.IsOverride) return false;
+            if (declaredSymbol is IPropertySymbol propertySymbol || declaredSymbol is IMethodSymbol methodSymbol) {
+                var methodSignature = declaredSymbol.GetUnqualifiedMethodOrPropertySignature(true);
+                return declaredSymbol.ContainingType.FollowProperty(s => s.BaseType).Skip(1).Any(t => t.GetMembers()
+                    .Any(s => s.Name == declaredSymbol.Name && (s is IPropertySymbol || s is IMethodSymbol) && s.GetUnqualifiedMethodOrPropertySignature(true) == methodSignature));
+            }
+            return null;
         }
 
         private static bool ContextHasIdenticalDefaults(TokenContext context, TokenContext[] contextsWithIdenticalDefaults, ISymbol declaredSymbol)
@@ -511,10 +532,10 @@ private async Task<ExpressionSyntax> IncreaseArrayUpperBoundExpressionAsync(VBSy
         {
             // These attributes' semantic effects are expressed differently in CSharp.
             return await attributeList.Attributes.Where(a => !IsExtensionAttribute(a) && !IsOutAttribute(a))
-                .SelectAsync(async a => (CSSyntax.AttributeListSyntax)await a.AcceptAsync(TriviaConvertingExpressionVisitor));
+                .SelectAsync(async a => await a.AcceptAsync<CSSyntax.AttributeListSyntax>(TriviaConvertingExpressionVisitor));
         }
 
-        public static AttributeArgumentListSyntax CreateAttributeArgumentList(params AttributeArgumentSyntax[] attributeArgumentSyntaxs)
+        public static CSSyntax.AttributeArgumentListSyntax CreateAttributeArgumentList(params CSSyntax.AttributeArgumentSyntax[] attributeArgumentSyntaxs)
         {
             return SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(attributeArgumentSyntaxs));
         }
@@ -524,7 +545,7 @@ public static CSSyntax.LocalDeclarationStatementSyntax CreateLocalVariableDeclar
             return SyntaxFactory.LocalDeclarationStatement(CreateVariableDeclarationAndAssignment(variableName, initValue));
         }
 
-        public static VariableDeclarationSyntax CreateVariableDeclarationAndAssignment(string variableName,
+        public static CSSyntax.VariableDeclarationSyntax CreateVariableDeclarationAndAssignment(string variableName,
             ExpressionSyntax initValue, TypeSyntax explicitType = null)
         {
             CSSyntax.VariableDeclaratorSyntax variableDeclaratorSyntax = CreateVariableDeclarator(variableName, initValue);