Update types needed in 4.8.0

Author: GrahamTheCoder

CodeConverter/CSharp/CommonConversions.cs

@@ -674,7 +674,7 @@ public static ExpressionSyntax ThrowawayParameters(ExpressionSyntax invocable, i
         return SyntaxFactory.ParenthesizedLambdaExpression(parameters, SyntaxFactory.InvocationExpression(invocable));
     }
 
-    public static CSSyntax.ParameterListSyntax CreateParameterList(IEnumerable<SyntaxNode> ps)
+    public static CSSyntax.ParameterListSyntax CreateParameterList(IEnumerable<CSSyntax.ParameterSyntax> ps)
     {
         return SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(ps));
     }

CodeConverter/CSharp/HandledEventsAnalysis.cs

@@ -85,7 +85,7 @@ private PropertyDeclarationSyntax GetDeclarationsForHandlingBaseMembers((EventCo
         var prop = (PropertyDeclarationSyntax) _commonConversions.CsSyntaxGenerator.Declaration(basePropertyEventSubscription.PropertyDetails.Property);
         var modifiers = prop.Modifiers.RemoveWhere(m => m.IsKind(SyntaxKind.VirtualKeyword)).Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
         //TODO Stash away methodwithandles in constructor that don't match any symbol from that type, to match here against base symbols
-        return GetDeclarationsForFieldBackedProperty(basePropertyEventSubscription.HandledMethods, SyntaxFactory.List<SyntaxNode>(), modifiers, 
+        return GetDeclarationsForFieldBackedProperty(basePropertyEventSubscription.HandledMethods, SyntaxFactory.List<AttributeListSyntax>(), modifiers, 
             prop.Type, prop.Identifier, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.BaseExpression(), ValidSyntaxFactory.IdentifierName(prop.Identifier)));
     }
 

CodeConverter/CSharp/LambdaConverter.cs

@@ -67,7 +67,7 @@ private async Task<CSharpSyntaxNode> ConvertToFunctionDeclarationOrNullAsync(VBS
         // Could do: See if we can improve upon returning "object" for pretty much everything (which is what the symbols say)
         // I believe that in general, special VB functions such as MultiplyObject are designed to work the same as integer when given two integers for example.
         // If all callers currently pass an integer, perhaps it'd be more idiomatic in C# to specify "int", than to have Operators
-        var paramsWithTypes = anonFuncOp.Symbol.Parameters.Select(p => CommonConversions.CsSyntaxGenerator.ParameterDeclaration(p));
+        var paramsWithTypes = anonFuncOp.Symbol.Parameters.Select(p => (ParameterSyntax) CommonConversions.CsSyntaxGenerator.ParameterDeclaration(p));
 
         var paramListWithTypes = param.WithParameters(SyntaxFactory.SeparatedList(paramsWithTypes));
         if (potentialAncestorDeclarationOperation is IFieldInitializerOperation fieldInit) {

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -611,7 +611,7 @@ public override async Task<SyntaxList<StatementSyntax>> VisitForBlock(VBSyntax.F
         }
 
 
-        var preLoopStatements = new List<SyntaxNode>();
+        var preLoopStatements = new List<StatementSyntax>();
         var csToValue = await stmt.ToValue.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
         csToValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.ToValue, csToValue?.SkipIntoParens(), forceTargetType: controlVarType);
 

CodeConverter/CSharp/TypeConversionAnalyzer.cs

@@ -242,17 +242,17 @@ private CSSyntax.NameSyntax GetCommonDelegateTypeOrNull(VBSyntax.ExpressionSynta
     private CSSyntax.NameSyntax CreateCommonDelegateTypeSyntax(IMethodSymbol vbLambda)
     {
         var parameters = vbLambda.Parameters
-            .Select(p => _csSyntaxGenerator.TypeExpression(p.Type));
+            .Select(p => (TypeSyntax) _csSyntaxGenerator.TypeExpression(p.Type));
 
         if (vbLambda.ReturnType.IsSystemVoid()) {
             return CreateType("Action", parameters);
         }
 
-        var typeExpression = _csSyntaxGenerator.TypeExpression(vbLambda.ReturnType);
+        var typeExpression = (TypeSyntax) _csSyntaxGenerator.TypeExpression(vbLambda.ReturnType);
         return CreateType("Func", parameters.Concat(typeExpression));
     }
 
-    private static CSSyntax.NameSyntax CreateType(string baseTypeName, IEnumerable<SyntaxNode> parameters)
+    private static CSSyntax.NameSyntax CreateType(string baseTypeName, IEnumerable<TypeSyntax> parameters)
     {
         var parameterList = SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(parameters));
         if (!parameterList.Arguments.Any()) return ValidSyntaxFactory.IdentifierName(baseTypeName);

CodeConverter/VB/NodesVisitor.cs

@@ -657,7 +657,7 @@ public override VisualBasicSyntaxNode VisitEventDeclaration(CSSyntax.EventDeclar
                 );
             } else {
                 if ((int)LanguageVersion < 14) {
-                    var conditionalStatement = _vbSyntaxGenerator.IfStatement(
+                    var conditionalStatement = (StatementSyntax) _vbSyntaxGenerator.IfStatement(
                         _vbSyntaxGenerator.ReferenceNotEqualsExpression(eventFieldIdentifier,
                             _vbSyntaxGenerator.NullLiteralExpression()),
                         SyntaxFactory.InvocationExpression(