Remove need to pass generator parameter to helper methods (#76627)

Author: CyrusNajmabadi

src/Analyzers/CSharp/CodeFixes/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs

@@ -160,7 +160,7 @@ protected static ImmutableArray<SyntaxNode> GenerateAssignmentStatements(
         {
             result.Add(generator.ExpressionStatement(generator.AssignmentStatement(
                 generator.IdentifierName(parameter.Name),
-                ExpressionGenerator.GenerateExpression(generator, parameter.Type, value: null, canUseFieldReference: false))));
+                ExpressionGenerator.GenerateExpression(parameter.Type, value: null, canUseFieldReference: false))));
         }
 
         return result.ToImmutableAndFree();

src/Analyzers/CSharp/CodeFixes/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs

@@ -99,7 +99,7 @@ protected override async Task FixAllAsync(
         foreach (var (localDeclaration, anonymousFunction, references) in nodesFromDiagnostics.OrderByDescending(nodes => nodes.function.SpanStart))
         {
             var delegateType = (INamedTypeSymbol)semanticModel.GetTypeInfo(anonymousFunction, cancellationToken).ConvertedType;
-            var parameterList = GenerateParameterList(editor.Generator, anonymousFunction, delegateType.DelegateInvokeMethod);
+            var parameterList = GenerateParameterList(anonymousFunction, delegateType.DelegateInvokeMethod);
             var makeStatic = MakeStatic(semanticModel, makeStaticIfPossible, localDeclaration, cancellationToken);
 
             var currentLocalDeclaration = currentRoot.GetCurrentNode(localDeclaration);
@@ -237,17 +237,17 @@ private static LocalFunctionStatementSyntax CreateLocalFunctionStatement(
     }
 
     private static ParameterListSyntax GenerateParameterList(
-        SyntaxGenerator generator, AnonymousFunctionExpressionSyntax anonymousFunction, IMethodSymbol delegateMethod)
+        AnonymousFunctionExpressionSyntax anonymousFunction, IMethodSymbol delegateMethod)
     {
         var parameterList = TryGetOrCreateParameterList(anonymousFunction);
         var i = 0;
 
         return parameterList != null
-            ? parameterList.ReplaceNodes(parameterList.Parameters, (parameterNode, _) => PromoteParameter(generator, parameterNode, delegateMethod.Parameters.ElementAtOrDefault(i++)))
+            ? parameterList.ReplaceNodes(parameterList.Parameters, (parameterNode, _) => PromoteParameter(parameterNode, delegateMethod.Parameters.ElementAtOrDefault(i++)))
             : ParameterList([.. delegateMethod.Parameters.Select(parameter =>
-                PromoteParameter(generator, Parameter(parameter.Name.ToIdentifierToken()), parameter))]);
+                PromoteParameter(Parameter(parameter.Name.ToIdentifierToken()), parameter))]);
 
-        static ParameterSyntax PromoteParameter(SyntaxGenerator generator, ParameterSyntax parameterNode, IParameterSymbol delegateParameter)
+        static ParameterSyntax PromoteParameter(ParameterSyntax parameterNode, IParameterSymbol delegateParameter)
         {
             // delegateParameter may be null, consider this case: Action x = (a, b) => { };
             // we will still fall back to object
@@ -259,7 +259,7 @@ static ParameterSyntax PromoteParameter(SyntaxGenerator generator, ParameterSynt
 
             if (delegateParameter?.HasExplicitDefaultValue == true)
             {
-                parameterNode = parameterNode.WithDefault(GetDefaultValue(generator, delegateParameter));
+                parameterNode = parameterNode.WithDefault(GetDefaultValue(delegateParameter));
             }
 
             return parameterNode;
@@ -312,6 +312,6 @@ private static int TryDetermineParameterIndex(NameColonSyntax argumentNameColon,
         return method.Parameters.IndexOf(p => p.Name == name);
     }
 
-    private static EqualsValueClauseSyntax GetDefaultValue(SyntaxGenerator generator, IParameterSymbol parameter)
-        => EqualsValueClause(ExpressionGenerator.GenerateExpression(generator, parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));
+    private static EqualsValueClauseSyntax GetDefaultValue(IParameterSymbol parameter)
+        => EqualsValueClause(ExpressionGenerator.GenerateExpression(parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));
 }

src/Features/CSharp/Portable/CodeRefactorings/InlineMethod/CSharpInlineMethodRefactoringProvider.cs

@@ -60,7 +60,7 @@ protected override SyntaxNode GenerateTypeSyntax(ITypeSymbol symbol, bool allowV
         => symbol.GenerateTypeSyntax(allowVar);
 
     protected override ExpressionSyntax GenerateLiteralExpression(ITypeSymbol typeSymbol, object? value)
-        => ExpressionGenerator.GenerateExpression(CSharpSyntaxGenerator.Instance, typeSymbol, value, canUseFieldReference: true);
+        => ExpressionGenerator.GenerateExpression(typeSymbol, value, canUseFieldReference: true);
 
     protected override bool IsFieldDeclarationSyntax(SyntaxNode node)
         => node.IsKind(SyntaxKind.FieldDeclaration);

src/Features/CSharp/Portable/IntroduceParameter/CSharpIntroduceParameterCodeRefactoringProvider.cs

@@ -12,22 +12,19 @@
 namespace Microsoft.CodeAnalysis.CSharp.IntroduceParameter;
 
 [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.IntroduceParameter), Shared]
-internal sealed partial class CSharpIntroduceParameterCodeRefactoringProvider : AbstractIntroduceParameterCodeRefactoringProvider<
+[method: ImportingConstructor]
+[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
+internal sealed partial class CSharpIntroduceParameterCodeRefactoringProvider()
+    : AbstractIntroduceParameterCodeRefactoringProvider<
     ExpressionSyntax,
     InvocationExpressionSyntax,
     ObjectCreationExpressionSyntax,
     IdentifierNameSyntax,
     ArgumentSyntax>
 {
-    [ImportingConstructor]
-    [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-    public CSharpIntroduceParameterCodeRefactoringProvider()
-    {
-    }
-
     protected override SyntaxNode GenerateExpressionFromOptionalParameter(IParameterSymbol parameterSymbol)
     {
-        return ExpressionGenerator.GenerateExpression(CSharpSyntaxGenerator.Instance, parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue, canUseFieldReference: true);
+        return ExpressionGenerator.GenerateExpression(parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue, canUseFieldReference: true);
     }
 
     protected override SyntaxNode? GetLocalDeclarationFromDeclarator(SyntaxNode variableDecl)

src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs

@@ -3134,17 +3134,6 @@ private static StatementSyntax AsStatement(SyntaxNode node)
     public override SyntaxNode ExpressionStatement(SyntaxNode expression)
         => SyntaxFactory.ExpressionStatement((ExpressionSyntax)expression);
 
-    internal override SyntaxNode MemberAccessExpressionWorker(SyntaxNode? expression, SyntaxNode simpleName)
-    {
-        // can only be null in VB
-        Contract.ThrowIfNull(expression);
-
-        return SyntaxFactory.MemberAccessExpression(
-            SyntaxKind.SimpleMemberAccessExpression,
-            ParenthesizeLeft((ExpressionSyntax)expression),
-            (SimpleNameSyntax)simpleName);
-    }
-
     public override SyntaxNode ConditionalAccessExpression(SyntaxNode expression, SyntaxNode whenNotNull)
         => SyntaxGeneratorInternal.ConditionalAccessExpression(expression, whenNotNull);
 
@@ -3155,27 +3144,6 @@ public override SyntaxNode ElementBindingExpression(IEnumerable<SyntaxNode> argu
         => SyntaxFactory.ElementBindingExpression(
             SyntaxFactory.BracketedArgumentList([.. arguments.Cast<ArgumentSyntax>()]));
 
-    /// <summary>
-    /// Parenthesize the left hand size of a member access, invocation or element access expression
-    /// </summary>
-    private static ExpressionSyntax ParenthesizeLeft(ExpressionSyntax expression)
-    {
-        if (expression is TypeSyntax ||
-            expression.Kind()
-                is SyntaxKind.ThisExpression
-                or SyntaxKind.BaseExpression
-                or SyntaxKind.ParenthesizedExpression
-                or SyntaxKind.SimpleMemberAccessExpression
-                or SyntaxKind.InvocationExpression
-                or SyntaxKind.ElementAccessExpression
-                or SyntaxKind.MemberBindingExpression)
-        {
-            return expression;
-        }
-
-        return (ExpressionSyntax)Parenthesize(expression);
-    }
-
     private static SeparatedSyntaxList<ExpressionSyntax> AsExpressionList(IEnumerable<SyntaxNode> expressions)
         => [.. expressions.OfType<ExpressionSyntax>()];
 
@@ -3212,52 +3180,14 @@ private static ArgumentSyntax AsArgument(SyntaxNode argOrExpression)
         => argOrExpression as ArgumentSyntax ?? SyntaxFactory.Argument((ExpressionSyntax)argOrExpression);
 
     public override SyntaxNode InvocationExpression(SyntaxNode expression, IEnumerable<SyntaxNode> arguments)
-        => SyntaxFactory.InvocationExpression(ParenthesizeLeft((ExpressionSyntax)expression), CreateArgumentList(arguments));
+        => SyntaxFactory.InvocationExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), CreateArgumentList(arguments));
 
     public override SyntaxNode ElementAccessExpression(SyntaxNode expression, IEnumerable<SyntaxNode> arguments)
-        => SyntaxFactory.ElementAccessExpression(ParenthesizeLeft((ExpressionSyntax)expression), SyntaxFactory.BracketedArgumentList(CreateArguments(arguments)));
+        => SyntaxFactory.ElementAccessExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), SyntaxFactory.BracketedArgumentList(CreateArguments(arguments)));
 
     internal override SyntaxToken NumericLiteralToken(string text, ulong value)
         => SyntaxFactory.Literal(text, value);
 
-    public override SyntaxNode DefaultExpression(SyntaxNode type)
-        => SyntaxFactory.DefaultExpression((TypeSyntax)type).WithAdditionalAnnotations(Simplifier.Annotation);
-
-    public override SyntaxNode DefaultExpression(ITypeSymbol type)
-    {
-        // If it's just a reference type, then "null" is the default expression for it.  Note:
-        // this counts for actual reference type, or a type parameter with a 'class' constraint.
-        // Also, if it's a nullable type, then we can use "null".
-        if (type.IsReferenceType ||
-            type is IPointerTypeSymbol ||
-            type.IsNullable())
-        {
-            return SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
-        }
-
-        switch (type.SpecialType)
-        {
-            case SpecialType.System_Boolean:
-                return SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
-            case SpecialType.System_SByte:
-            case SpecialType.System_Byte:
-            case SpecialType.System_Int16:
-            case SpecialType.System_UInt16:
-            case SpecialType.System_Int32:
-            case SpecialType.System_UInt32:
-            case SpecialType.System_Int64:
-            case SpecialType.System_UInt64:
-            case SpecialType.System_Decimal:
-            case SpecialType.System_Single:
-            case SpecialType.System_Double:
-                return SyntaxFactory.LiteralExpression(
-                    SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("0", 0));
-        }
-
-        // Default to a "default(<typename>)" expression.
-        return DefaultExpression(type.GenerateTypeSyntax());
-    }
-
     private static SyntaxNode Parenthesize(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true)
         => CSharpSyntaxGeneratorInternal.Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation);
 
@@ -3270,17 +3200,11 @@ public override SyntaxNode TypeOfExpression(SyntaxNode type)
     public override SyntaxNode TryCastExpression(SyntaxNode expression, SyntaxNode type)
         => SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, (ExpressionSyntax)Parenthesize(expression), (TypeSyntax)type);
 
-    public override SyntaxNode CastExpression(SyntaxNode type, SyntaxNode expression)
-        => SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)Parenthesize(expression)).WithAdditionalAnnotations(Simplifier.Annotation);
-
-    public override SyntaxNode ConvertExpression(SyntaxNode type, SyntaxNode expression)
-        => SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)Parenthesize(expression)).WithAdditionalAnnotations(Simplifier.Annotation);
-
     public override SyntaxNode AssignmentStatement(SyntaxNode left, SyntaxNode right)
         => SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)left, (ExpressionSyntax)Parenthesize(right));
 
     private static SyntaxNode CreateBinaryExpression(SyntaxKind syntaxKind, SyntaxNode left, SyntaxNode right)
-        => SyntaxFactory.BinaryExpression(syntaxKind, (ExpressionSyntax)Parenthesize(left), (ExpressionSyntax)Parenthesize(right));
+        => CSharpSyntaxGeneratorInternal.CreateBinaryExpression(syntaxKind, left, right);
 
     public override SyntaxNode ValueEqualsExpression(SyntaxNode left, SyntaxNode right)
         => CreateBinaryExpression(SyntaxKind.EqualsExpression, left, right);
@@ -3327,9 +3251,6 @@ public override SyntaxNode ModuloExpression(SyntaxNode left, SyntaxNode right)
     public override SyntaxNode BitwiseAndExpression(SyntaxNode left, SyntaxNode right)
         => CreateBinaryExpression(SyntaxKind.BitwiseAndExpression, left, right);
 
-    public override SyntaxNode BitwiseOrExpression(SyntaxNode left, SyntaxNode right)
-        => CreateBinaryExpression(SyntaxKind.BitwiseOrExpression, left, right);
-
     public override SyntaxNode BitwiseNotExpression(SyntaxNode operand)
         => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, (ExpressionSyntax)Parenthesize(operand));
 
@@ -3355,13 +3276,10 @@ public override SyntaxNode BaseExpression()
         => SyntaxFactory.BaseExpression();
 
     public override SyntaxNode TypedConstantExpression(TypedConstant value)
-        => ExpressionGenerator.GenerateExpression(this, value);
+        => ExpressionGenerator.GenerateExpression(value);
 
     private protected override SyntaxNode GenerateExpression(ITypeSymbol? type, object? value, bool canUseFieldReference)
-        => ExpressionGenerator.GenerateExpression(this, type, value, canUseFieldReference);
-
-    public override SyntaxNode IdentifierName(string identifier)
-        => identifier.ToIdentifierName();
+        => ExpressionGenerator.GenerateExpression(type, value, canUseFieldReference);
 
     public override SyntaxNode GenericName(string identifier, IEnumerable<SyntaxNode> typeArguments)
         => GenericName(identifier.ToIdentifierToken(), typeArguments);
@@ -3411,17 +3329,6 @@ internal override SyntaxNode GlobalAliasedName(SyntaxNode name)
     public override SyntaxNode NameExpression(INamespaceOrTypeSymbol namespaceOrTypeSymbol)
         => namespaceOrTypeSymbol.GenerateNameSyntax();
 
-    private protected override SyntaxNode TypeExpression(ITypeSymbol typeSymbol, RefKind refKind)
-    {
-        var type = typeSymbol.GenerateTypeSyntax();
-        return refKind switch
-        {
-            RefKind.Ref => SyntaxFactory.RefType(type),
-            RefKind.RefReadOnly => SyntaxFactory.RefType(RefKeyword, ReadOnlyKeyword, type),
-            _ => type,
-        };
-    }
-
     public override SyntaxNode TypeExpression(SpecialType specialType)
         => SyntaxFactory.PredefinedType(specialType switch
         {