WithTriviaFrom

348 references to WithTriviaFrom

GenerateDocumentationAndConfigFiles (8)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (8)

75.WithTriviaFrom(expressionOrPattern); 100.WithTriviaFrom(expressionOrPattern); 175newBinaryExpressionSyntax = newBinaryExpressionSyntax.WithTriviaFrom(expressionNode); 185return generatorInternal.IsPatternExpression(leftOperand, operatorToken, generatorInternal.ConstantPattern(generator.NullLiteralExpression().WithTriviaFrom(rightOperand))); 219generatorInternal.NotPattern(innerPattern.WithTriviaFrom(rightOperand))); 251newPattern = newPattern.WithTriviaFrom(pattern); 494return newLiteralExpression.WithTriviaFrom(expression); 569generator.NullLiteralExpression().WithTriviaFrom(type)));

Microsoft.Analyzers.Extra (1)

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

520var call = gen.InvocationExpression(memberAccessExpression, argList).WithTriviaFrom(invocationExpression);

Microsoft.Build.TaskAuthoring.Analyzer (5)

PreferTypedParameterCodeFixProvider.cs (5)

587.WithTriviaFrom(conversion) 601.WithTriviaFrom(getFullPath) 625.WithTriviaFrom(propertyAccess) 772.WithTriviaFrom(conversion) 956.WithTriviaFrom(plan.PropertyDeclaration.Type)

Microsoft.CodeAnalysis.Analyzers (12)

MetaAnalyzers\Fixers\CompareSymbolsCorrectlyFix.cs (3)

140editor.ReplaceNode(nodeToReplace, replacement.WithTriviaFrom(nodeToReplace)); 212editor.ReplaceNode(nodeToReplace, replacement.WithTriviaFrom(nodeToReplace)); 285editor.ReplaceNode(expression, replacement.WithTriviaFrom(expression));

MetaAnalyzers\Fixers\DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs (1)

166var newLiteral = generator.LiteralExpression(fixInfo.FixValue).WithTriviaFrom(literal.Syntax);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (8)

Microsoft.CodeAnalysis.CodeStyle.Fixes (30)

src\939a5660f39ce290\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)

123WrapWithBlockIfAppropriate(ifStatement, expressionStatement).WithTriviaFrom(ifStatement));

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

150return (targetNode, this.Cast(castedExpression, conversionType).WithTriviaFrom(targetNode));

src\roslyn\src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

70generator.WithModifiers(fieldDeclaration.WithoutTrivia(), modifiers).WithTriviaFrom(fieldDeclaration));

src\roslyn\src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (2)

230.WithTriviaFrom(currentAwaitExpression)); 252return currentInvocationExpression.WithTriviaFrom(currentAwaitExpression);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveAsyncModifier\AbstractRemoveAsyncModifierCodeFixProvider.cs (1)

228return generator.InvocationExpression(taskFromResult, expression.WithoutTrivia()).WithTriviaFrom(expression);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (2)

417.WithTriviaFrom(node) 432.WithTriviaFrom(node)

src\roslyn\src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

80return generatorInternal.AddParentheses(replacement.WithTriviaFrom(expr));

src\roslyn\src\Analyzers\Core\CodeFixes\SimplifyLinqExpression\SimplifyLinqExpressionCodeFixProvider.cs (1)

84return innerInvocationExpression.ReplaceNode(innerName, outerName.WithTriviaFrom(innerName)).WithTrailingTrivia(current.GetTrailingTrivia());

src\roslyn\src\Analyzers\Core\CodeFixes\UpdateLegacySuppressions\UpdateLegacySuppressionsCodeFixProvider.cs (1)

46editor.ReplaceNode(node, editor.Generator.LiteralExpression(newDocCommentId).WithTriviaFrom(node));

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (3)

356editor.ReplaceNode(node, qualifiedName.WithTriviaFrom(node)); 361editor.ReplaceNode(node, newNameNode.WithTriviaFrom(node)); 370editor.ReplaceNode(node, newNameNode.WithTriviaFrom(node));

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullStatementCheckCodeFixProvider.cs (1)

51GetWhenNullExpression(whenTrueStatement).WithoutTrailingTrivia()).WithTriviaFrom(expressionToCoalesce));

src\roslyn\src\Analyzers\Core\CodeFixes\UseCompoundAssignment\AbstractUseCompoundAssignmentCodeFixProvider.cs (2)

76return Increment((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment); 79return Decrement((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment);

src\roslyn\src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForReturn\AbstractUseConditionalExpressionForReturnCodeFixProvider.cs (1)

82returnStatement = returnStatement.WithTriviaFrom(ifStatement);

src\roslyn\src\Analyzers\Core\CodeFixes\UseExplicitTupleName\UseExplicitTupleNameCodeFixProvider.cs (1)

45var newNameNode = generator.IdentifierName(preferredName).WithTriviaFrom(oldNameNode);

src\roslyn\src\Analyzers\Core\CodeFixes\UseIsNullCheck\AbstractUseIsNullForReferenceEqualsCodeFixProvider.cs (1)

75replacement.WithTriviaFrom(toReplace));

src\roslyn\src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)

125conditionalPart.WithTriviaFrom(conditionalExpression)); 151newNode = newNode.WithTriviaFrom(conditionalExpression);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (8)

Microsoft.CodeAnalysis.CSharp.CodeStyle (3)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

682? newCollectionExpression.WithTriviaFrom(initializerParent)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitlyTypedLambdaExpressionDiagnosticAnalyzer.cs (1)

116parameter.WithTriviaFrom(explicitLambda.ParameterList),

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

177SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (53)

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToAsync\CSharpConvertToAsyncMethodCodeFixProvider.cs (1)

99.WithTriviaFrom(methodDeclaration));

src\roslyn\src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (1)

156newExpr = newExpr.WithTriviaFrom(nameNode);

src\roslyn\src\Analyzers\CSharp\CodeFixes\FixReturnType\CSharpFixReturnTypeCodeFixProvider.cs (1)

121fixedDeclaration = fixedDeclaration.WithAdditionalAnnotations(Simplifier.Annotation).WithTriviaFrom(declarationTypeToFix);

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

140(node, generator) => IdentifierName(parameter.Name.ToIdentifierToken()).WithTriviaFrom(node));

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeMethodAsynchronous\CSharpMakeMethodAsynchronousCodeFixProvider.cs (1)

168return newReturnType.WithTriviaFrom(returnTypeSyntax).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation);

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeMethodSynchronous\CSharpMakeMethodSynchronousCodeFixProvider.cs (2)

64newReturnType = SyntaxFactory.PredefinedType(VoidKeyword).WithTriviaFrom(returnTypeSyntax); 69newReturnType = returnType.GetTypeArguments()[0].GenerateTypeSyntax().WithTriviaFrom(returnTypeSyntax);

src\roslyn\src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

105var fixedDeclaration = SyntaxFactory.NullableType(declarationTypeToFix.WithoutTrivia()).WithTriviaFrom(declarationTypeToFix);

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs (1)

54return invocation.Expression.WithTriviaFrom(current).Parenthesize();

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryNullableWarningSuppressionsCodeFixProvider.cs (1)

97var result = ((PostfixUnaryExpressionSyntax)current).Operand.WithTriviaFrom(current);

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnusedParametersAndValues\CSharpRemoveUnusedValuesCodeFixProvider.cs (4)

73? DiscardDesignation().WithTriviaFrom(node) 74: SingleVariableDesignation(newName).WithTriviaFrom(node); 82? DiscardPattern().WithTriviaFrom(node) 250return pattern.WithDesignation(discardDesignation.WithTriviaFrom(pattern.Designation));

src\roslyn\src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)

72var newRoot = syntaxRoot.ReplaceNode(defaultLiteral, newExpression.WithTriviaFrom(defaultLiteral));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseAutoProperty\UseAutoPropertyRewriter.cs (4)

29return FieldExpression().WithTriviaFrom(node); 34return node.WithName(_propertyIdentifierName.WithTriviaFrom(identifierName)); 51return _propertyIdentifierName.WithTriviaFrom(node); 55return FieldExpression().WithTriviaFrom(node);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (3)

190return collectionExpression.WithTriviaFrom(expressionToReplace); 207return CollectionExpression([CreateElement(match)]).WithTriviaFrom(expressionToReplace); 554.WithTriviaFrom(indentedExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

124.WithTriviaFrom(creationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)

59.WithTriviaFrom(invocationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForEmptyCodeFixProvider.cs (1)

42(current, _) => s_emptyCollection.WithTriviaFrom(current));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)

82.WithTriviaFrom(invocationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)

60.WithTriviaFrom(objectCreationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentCodeFixProvider.cs (1)

63assignment.Right).WithTriviaFrom(assignment);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

106return currentMemberAccess.Name.WithTriviaFrom(currentMemberAccess);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)

59SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression).WithTriviaFrom(defaultExpression)),

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (1)

241.WithTriviaFrom(typeSyntax);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseImplicitTypeCodeFixProvider.cs (1)

56.WithTriviaFrom(type);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorCodeFixProvider.cs (3)

83PredefinedType(ObjectKeyword)).WithTriviaFrom(isPattern); 97castExpr.Expression.WithTriviaFrom(binary.Left), 99ConstantPattern(nullLiteral).WithTriviaFrom(binary.Right));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs (1)

56editor.ReplaceNode(node, replacement.WithTriviaFrom(node));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLabeledJumpStatements\CSharpUseLabeledJumpStatementsCodeFixProvider.cs (2)

86var newLoop = loop.ReplaceNodes(gotos, (original, _) => CreateJump(labelName, isBreak).WithTriviaFrom(original)); 169(original, _) => CreateJump(labelName, pattern.IsBreak).WithTriviaFrom(original));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

160.WithTriviaFrom(localDeclaration) 189? invocation.WithExpression(memberAccess.Expression).WithTriviaFrom(invocation) // remove it

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseNameofInAttribute\CSharpUseNameofInAttributeCodeFixProvider.cs (1)

48editor.Generator.NameOfExpression(editor.Generator.IdentifierName(name)).WithTriviaFrom(expression));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndMemberAccessCodeFixProvider.cs (1)

87newIsExpression.WithTriviaFrom(toReplace));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndNullCheckCodeFixProvider.cs (1)

128editor.ReplaceNode(comparison, condition.WithTriviaFrom(comparison));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (2)

273return current.WithModifiers(current.Modifiers.Remove(inKeyword)).WithTriviaFrom(current); 616parameterNameNode.WithTriviaFrom(nodeToReplace));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (3)

103lockTypeExpression.WithTriviaFrom(variableDeclaration.Type)); 109lockTypeExpression.WithTriviaFrom(objectCreationExpression.Type)); 156lockTypeExpression.WithTriviaFrom(objectCreation.Type));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseTupleSwap\CSharpUseTupleSwapCodeFixProvider.cs (1)

63editor.ReplaceNode(localDeclarationStatement, tupleAssignmentStatement.WithTriviaFrom(localDeclarationStatement));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (3)

62return parenthesized.WithTriviaFrom(expression); 76var result = parenthesized.WithTriviaFrom(pattern); 88targetType.GenerateTypeSyntax(), parenthesized.WithoutTrivia()).WithTriviaFrom(parenthesized);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

127IdentifierName(fieldOrProperty.Name.EscapeIdentifier()).WithTriviaFrom(identifierName));

Microsoft.CodeAnalysis.CSharp.Features (81)

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

153currentNode = currentNode.WithIdentifier(identifierToken).WithTriviaFrom(currentNode);

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (3)

237anonymousMember.Update(NameEquals(identifier), expressionToInline).WithTriviaFrom(anonymousMember)); 257argument.Update(NameColon(identifier), argument.RefKindKeyword, expressionToInline).WithTriviaFrom(argument)); 275editor.ReplaceNode(identifier, expressionToInline.WithTriviaFrom(identifier));

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (3)

155newNode = newNode.WithTriviaFrom(oldNode); 172newNode = newNode.WithTriviaFrom(oldNode); 264.WithTriviaFrom(namespaceDecl.Name).WithAdditionalAnnotations(WarningAnnotation))

ConvertAnonymousType\CSharpConvertAnonymousTypeToTupleCodeRefactoringProvider.cs (1)

63=> Argument(ConvertName(declarator.NameEquals), refKindKeyword: default, declarator.Expression).WithTriviaFrom(declarator);

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

116(oldNode, _) => backingFieldExpression.WithTriviaFrom(oldNode));

ConvertBetweenRegularAndVerbatimString\AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (1)

88var newStringExpression = convert(charService, sb, stringExpression).WithTriviaFrom(stringExpression);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (4)

259mainDocumentEditor.ReplaceNode(baseType, (current, _) => SimpleBaseType(((PrimaryConstructorBaseTypeSyntax)current).Type).WithTriviaFrom(baseType)); 390editor.ReplaceNode(identifierName, fieldName.WithTriviaFrom(identifierName)); 511return memberAccessExpression.Name.WithTriviaFrom(node); 516return qualifiedName.Right.WithTriviaFrom(node);

ConvertProgram\ConvertProgramTransform_TopLevelStatements.cs (1)

214.WithTriviaFrom(fieldDeclaration));

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (2)

252return parsed.WithTriviaFrom(stringExpression); 632return parsed.WithTriviaFrom(stringExpression);

ConvertTupleToStruct\CSharpConvertTupleToStructCodeRefactoringProvider.cs (1)

45var newName = SyntaxFactory.IdentifierName(name).WithTriviaFrom(nameColon.Name);

Copilot\CSharpImplementNotImplementedExceptionFixProvider.cs (1)

121.WithTriviaFrom(methodOrProperty)

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (2)

435return ConvertExitPoint(current).WithTriviaFrom(current); 468Argument(NameColon(IdentifierName(ReturnValueName)), refKindKeyword: default, returnExpr.WithoutTrivia())]).WithTriviaFrom(returnExpr);

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (2)

131identifierName.WithoutTrivia()).WithTriviaFrom(identifierName)); 139g.CastExpression(interfaceType, current.WithoutTrivia())).WithTriviaFrom(current));

IntroduceUsingStatement\CSharpIntroduceUsingStatementCodeRefactoringProvider.cs (1)

79.WithSemicolonToken(expressionStatement.SemicolonToken).WithTriviaFrom(expressionStatement);

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (1)

261var newRoot = document.Root.ReplaceNode(oldParentingNode, WithBlockBody(oldParentingNode, newBody).WithTriviaFrom(oldParentingNode));

ReplaceConditionalWithStatements\CSharpReplaceConditionalWithStatementsCodeRefactoringProvider.cs (1)

74type, symbol.Type.GenerateTypeSyntax(allowVar: false).WithTriviaFrom(type));

ReplaceMethodWithProperty\CSharpReplaceMethodWithPropertyService.cs (2)

299return IdentifierName("value").WithTriviaFrom(node); 377newName = newName.WithTriviaFrom(invocation is null ? nameToken.Parent : invocation);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

682? newCollectionExpression.WithTriviaFrom(initializerParent)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitlyTypedLambdaExpressionDiagnosticAnalyzer.cs (1)

116parameter.WithTriviaFrom(explicitLambda.ParameterList),

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToAsync\CSharpConvertToAsyncMethodCodeFixProvider.cs (1)

99.WithTriviaFrom(methodDeclaration));

src\roslyn\src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (1)

156newExpr = newExpr.WithTriviaFrom(nameNode);

src\roslyn\src\Analyzers\CSharp\CodeFixes\FixReturnType\CSharpFixReturnTypeCodeFixProvider.cs (1)

121fixedDeclaration = fixedDeclaration.WithAdditionalAnnotations(Simplifier.Annotation).WithTriviaFrom(declarationTypeToFix);

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

140(node, generator) => IdentifierName(parameter.Name.ToIdentifierToken()).WithTriviaFrom(node));

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeMethodAsynchronous\CSharpMakeMethodAsynchronousCodeFixProvider.cs (1)

168return newReturnType.WithTriviaFrom(returnTypeSyntax).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation);

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeMethodSynchronous\CSharpMakeMethodSynchronousCodeFixProvider.cs (2)

64newReturnType = SyntaxFactory.PredefinedType(VoidKeyword).WithTriviaFrom(returnTypeSyntax); 69newReturnType = returnType.GetTypeArguments()[0].GenerateTypeSyntax().WithTriviaFrom(returnTypeSyntax);

src\roslyn\src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

105var fixedDeclaration = SyntaxFactory.NullableType(declarationTypeToFix.WithoutTrivia()).WithTriviaFrom(declarationTypeToFix);

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs (1)

54return invocation.Expression.WithTriviaFrom(current).Parenthesize();

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryNullableWarningSuppressionsCodeFixProvider.cs (1)

97var result = ((PostfixUnaryExpressionSyntax)current).Operand.WithTriviaFrom(current);

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnusedParametersAndValues\CSharpRemoveUnusedValuesCodeFixProvider.cs (4)

src\roslyn\src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)

72var newRoot = syntaxRoot.ReplaceNode(defaultLiteral, newExpression.WithTriviaFrom(defaultLiteral));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseAutoProperty\UseAutoPropertyRewriter.cs (4)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (3)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

124.WithTriviaFrom(creationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)

59.WithTriviaFrom(invocationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForEmptyCodeFixProvider.cs (1)

42(current, _) => s_emptyCollection.WithTriviaFrom(current));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)

82.WithTriviaFrom(invocationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)

60.WithTriviaFrom(objectCreationExpression)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentCodeFixProvider.cs (1)

63assignment.Right).WithTriviaFrom(assignment);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

106return currentMemberAccess.Name.WithTriviaFrom(currentMemberAccess);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)

59SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression).WithTriviaFrom(defaultExpression)),

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (1)

241.WithTriviaFrom(typeSyntax);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseImplicitTypeCodeFixProvider.cs (1)

56.WithTriviaFrom(type);

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorCodeFixProvider.cs (3)

83PredefinedType(ObjectKeyword)).WithTriviaFrom(isPattern); 97castExpr.Expression.WithTriviaFrom(binary.Left), 99ConstantPattern(nullLiteral).WithTriviaFrom(binary.Right));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseNullCheckOverTypeCheckCodeFixProvider.cs (1)

56editor.ReplaceNode(node, replacement.WithTriviaFrom(node));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLabeledJumpStatements\CSharpUseLabeledJumpStatementsCodeFixProvider.cs (2)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

160.WithTriviaFrom(localDeclaration) 189? invocation.WithExpression(memberAccess.Expression).WithTriviaFrom(invocation) // remove it

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseNameofInAttribute\CSharpUseNameofInAttributeCodeFixProvider.cs (1)

48editor.Generator.NameOfExpression(editor.Generator.IdentifierName(name)).WithTriviaFrom(expression));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndMemberAccessCodeFixProvider.cs (1)

87newIsExpression.WithTriviaFrom(toReplace));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndNullCheckCodeFixProvider.cs (1)

128editor.ReplaceNode(comparison, condition.WithTriviaFrom(comparison));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (2)

273return current.WithModifiers(current.Modifiers.Remove(inKeyword)).WithTriviaFrom(current); 616parameterNameNode.WithTriviaFrom(nodeToReplace));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (3)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseTupleSwap\CSharpUseTupleSwapCodeFixProvider.cs (1)

63editor.ReplaceNode(localDeclarationStatement, tupleAssignmentStatement.WithTriviaFrom(localDeclarationStatement));

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (2)

225SyntaxFactory.SingleVariableDesignation(newLocalName))).WithTriviaFrom(isExpression); 237localReference.WithTriviaFrom(castRoot)

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (24)

Microsoft.NetCore.Analyzers\Performance\CSharpCollapseMultiplePathOperations.Fixer.cs (1)

76.WithTriviaFrom(current);

Microsoft.NetCore.Analyzers\Performance\CSharpDoNotGuardCall.Fixer.cs (2)

54.WithTriviaFrom(currentConditional); 62.WithTriviaFrom(currentConditional);

Microsoft.NetCore.Analyzers\Performance\CSharpPreferDictionaryTryMethodsOverContainsKeyGuardFixer.cs (5)

220.ReplaceNode(fix.ContainsKeyAccess.Name, IdentifierName(TryGetValue).WithTriviaFrom(fix.ContainsKeyAccess.Name)) 238WithTriviaFrom(post)); 243WithTriviaFrom(post)); 247pre.WithOperand(identifierName)).WithTriviaFrom(pre)); 311var invocationWithTrivia = tryAddInvocation.WithTriviaFrom(ifStatement);

Microsoft.NetCore.Analyzers\Performance\CSharpPreferLengthCountIsEmptyOverAny.Fixer.cs (3)

43return newMemberAccess.WithTriviaFrom(currentNode); 49).WithTriviaFrom(currentNode); 70).WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Performance\CSharpRecommendCaseInsensitiveStringComparisonFixer.cs (1)

105arguments.Add(newArgumentNode.WithTriviaFrom(arg.Syntax));

Microsoft.NetCore.Analyzers\Runtime\CSharpPreferReadOnlySpanPropertiesOverReadOnlyArrayFields.Fixer.cs (6)

460replacements.Add((invocationSyntax, sourceExpression.WithTriviaFrom(invocationSyntax))); 495.WithTriviaFrom(invocationSyntax); 522.WithTriviaFrom(invocationSyntax.Expression); 533SyntaxFactory.IdentifierName(nameof(ReadOnlySpan<byte>.Slice)).WithTriviaFrom(memberAccessSyntax.Name))); 558return nullableArrayType.WithTriviaFrom(declarationType); 572.WithTriviaFrom(declarationType);

Microsoft.NetCore.Analyzers\Runtime\CSharpUseSpanBasedStringConcat.Fixer.cs (1)

21var newNameSyntax = generator.IdentifierName(newName).WithTriviaFrom(oldNameSyntax);

Microsoft.NetCore.Analyzers\Usage\CSharpPreferGenericOverloads.cs (1)

62.WithTriviaFrom(invocationSyntax);

Microsoft.NetCore.Analyzers\Usage\CSharpPreferGenericOverloads.Fixer.cs (2)

66.WithTriviaFrom(castExpressionSyntax)) 75.WithTriviaFrom(castExpressionSyntax));

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler.CSharp\Extensions\SyntaxNodeExtensions.cs (2)

75return parenthesized.WithTriviaFrom(expression); 89var result = parenthesized.WithTriviaFrom(pattern);

Microsoft.CodeAnalysis.CSharp.Workspaces (10)

Simplification\Reducers\CSharpDefaultExpressionReducer.Rewriter.cs (1)

38.WithTriviaFrom(node);

Simplification\Reducers\CSharpInferredMemberNameReducer.Rewriter.cs (2)

33return node.WithNameColon(null).WithTriviaFrom(node); 45return node.WithNameEquals(null).WithTriviaFrom(node);

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (1)

376return node.WithTriviaFrom(nodeToReplace);

Simplification\Simplifiers\ExpressionSimplifier.cs (1)

446replacementNode = replacementNode.WithTriviaFrom(left);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

177SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (3)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

127IdentifierName(fieldOrProperty.Name.EscapeIdentifier()).WithTriviaFrom(identifierName));

Microsoft.CodeAnalysis.Features (48)

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (1)

126.WithTriviaFrom(expression);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (1)

172(currentId, g) => g.IdentifierName(newName).WithTriviaFrom(currentId));

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

497generator.IdentifierName(replacementToken).WithTriviaFrom(indexMatch));

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

352editor.ReplaceNode(invocation, replacementNode.WithTriviaFrom(invocation));

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

103generator.CreateInterpolatedStringEndToken()).WithTriviaFrom(literalExpression);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

744return (TArgumentSyntax)generator.Argument(expr).WithTriviaFrom(argument); 794return typeNameNode.WithTriviaFrom(currentNode);

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (7)

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (1)

308var replacementNodeWithTrivia = syntaxNode.WithTriviaFrom(nodeToReplace);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (2)

55editor.ReplaceNode(whenTrue, whenFalse.WithTriviaFrom(whenTrue)); 56editor.ReplaceNode(whenFalse, whenTrue.WithTriviaFrom(whenFalse));

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (2)

316.WithTriviaFrom(refNode) 343.WithTriviaFrom(refNode)

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

86var newArgument = WithName(argument, elementName).WithTriviaFrom(argument);

PreferFrameworkType\PreferFrameworkTypeCodeFixProvider.cs (1)

54editor.ReplaceNode(node, replacementNode.WithTriviaFrom(node));

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

212cancellationToken).WithTriviaFrom(statement); 299var containerWithConditionalReplaced = container.ReplaceNode(conditionalExpression, TryConvert(expression, conditionalType).WithTriviaFrom(conditionalExpression));

ReplacePropertyWithMethods\AbstractReplacePropertyWithMethodsService.cs (2)

345newIdentifierName = newIdentifierName.WithTriviaFrom(_identifierName); 368newIdentifierName = newIdentifierName.WithTriviaFrom(_identifierName);

src\939a5660f39ce290\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)

123WrapWithBlockIfAppropriate(ifStatement, expressionStatement).WithTriviaFrom(ifStatement));

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

150return (targetNode, this.Cast(castedExpression, conversionType).WithTriviaFrom(targetNode));

src\roslyn\src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

70generator.WithModifiers(fieldDeclaration.WithoutTrivia(), modifiers).WithTriviaFrom(fieldDeclaration));

src\roslyn\src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (2)

230.WithTriviaFrom(currentAwaitExpression)); 252return currentInvocationExpression.WithTriviaFrom(currentAwaitExpression);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveAsyncModifier\AbstractRemoveAsyncModifierCodeFixProvider.cs (1)

228return generator.InvocationExpression(taskFromResult, expression.WithoutTrivia()).WithTriviaFrom(expression);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (2)

417.WithTriviaFrom(node) 432.WithTriviaFrom(node)

src\roslyn\src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

80return generatorInternal.AddParentheses(replacement.WithTriviaFrom(expr));

src\roslyn\src\Analyzers\Core\CodeFixes\SimplifyLinqExpression\SimplifyLinqExpressionCodeFixProvider.cs (1)

84return innerInvocationExpression.ReplaceNode(innerName, outerName.WithTriviaFrom(innerName)).WithTrailingTrivia(current.GetTrailingTrivia());

src\roslyn\src\Analyzers\Core\CodeFixes\UpdateLegacySuppressions\UpdateLegacySuppressionsCodeFixProvider.cs (1)

46editor.ReplaceNode(node, editor.Generator.LiteralExpression(newDocCommentId).WithTriviaFrom(node));

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (3)

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullStatementCheckCodeFixProvider.cs (1)

51GetWhenNullExpression(whenTrueStatement).WithoutTrailingTrivia()).WithTriviaFrom(expressionToCoalesce));

src\roslyn\src\Analyzers\Core\CodeFixes\UseCompoundAssignment\AbstractUseCompoundAssignmentCodeFixProvider.cs (2)

src\roslyn\src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForReturn\AbstractUseConditionalExpressionForReturnCodeFixProvider.cs (1)

82returnStatement = returnStatement.WithTriviaFrom(ifStatement);

src\roslyn\src\Analyzers\Core\CodeFixes\UseExplicitTupleName\UseExplicitTupleNameCodeFixProvider.cs (1)

45var newNameNode = generator.IdentifierName(preferredName).WithTriviaFrom(oldNameNode);

src\roslyn\src\Analyzers\Core\CodeFixes\UseIsNullCheck\AbstractUseIsNullForReferenceEqualsCodeFixProvider.cs (1)

75replacement.WithTriviaFrom(toReplace));

src\roslyn\src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)

125conditionalPart.WithTriviaFrom(conditionalExpression)); 151newNode = newNode.WithTriviaFrom(conditionalExpression);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

156? WithName((TSimpleArgumentSyntax)argument.WithoutTrivia(), parameters[i].Name).WithTriviaFrom(argument)

Microsoft.CodeAnalysis.NetAnalyzers (34)

Microsoft.CodeQuality.Analyzers\Maintainability\MakeTypesInternal.Fixer.cs (1)

32editor.ReplaceNode(node, (currentNode, _) => MakeInternal(currentNode).WithTriviaFrom(currentNode));

Microsoft.NetCore.Analyzers\ImmutableCollections\DoNotCallToImmutableCollectionOnAnImmutableCollectionValue.Fixer.cs (1)

65var instance = invocationOperation.GetInstanceSyntax()!.WithTriviaFrom(invocationNode);

Microsoft.NetCore.Analyzers\Performance\DoNotUseCountWhenAnyCanBeUsed.Fixer.cs (1)

127.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Performance\PreferConvertToHexStringOverBitConverter.Fixer.cs (1)

126return methodInvocation.WithTriviaFrom(currentOuterInvocation);

Microsoft.NetCore.Analyzers\Performance\PreferIsEmptyOverCount.Fixer.cs (1)

76return isEmptyNode.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Performance\RecommendCaseInsensitiveStringComparison.Fixer.cs (4)

179SyntaxNode newInvocation = generator.InvocationExpression(stringMemberAccessExpression, newArguments).WithTriviaFrom(mainInvocation.Syntax); 181SyntaxNode newRoot = generator.ReplaceNode(root, mainInvocation.Syntax, newInvocation.WithTriviaFrom(mainInvocation.Syntax)); 196SyntaxNode memberAccess = generator.MemberAccessExpression(leftNode, RCISCAnalyzer.StringEqualsMethodName).WithTriviaFrom(leftNode); 211SyntaxNode newRoot = generator.ReplaceNode(root, binaryOperation.Syntax, replacement.WithTriviaFrom(binaryOperation.Syntax));

Microsoft.NetCore.Analyzers\Performance\UsePropertyInsteadOfCountMethodWhenAvailable.Fixer.cs (1)

76.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Performance\UseStringMethodCharOverloadWithSingleCharacters.Fixer.cs (1)

62return CreateArgumentList(arguments).WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\AvoidConstArrays.Fixer.cs (1)

169editor.ReplaceNode(node, generator.Argument(identifier).WithTriviaFrom(arrayArgument.Syntax));

Microsoft.NetCore.Analyzers\Runtime\AvoidUnreliableStreamRead.Fixer.cs (1)

86.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\AvoidZeroLengthArrayAllocations.Fixer.cs (1)

57SyntaxNode arrayEmptyInvocation = GenerateArrayEmptyInvocation(generator, arrayTypeSymbol, elementType).WithTriviaFrom(nodeToFix);

Microsoft.NetCore.Analyzers\Runtime\ForwardCancellationTokenToInvocations.Fixer.cs (1)

93return GenerateInvocation(generator, fix, expression, currentArguments.MoveToImmutable()).WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\PreferConstCharOverConstUnitString.Fixer.cs (1)

86editor.ReplaceNode(target, charSyntaxNode.WithTriviaFrom(target));

Microsoft.NetCore.Analyzers\Runtime\PreferJsonElementParse.Fixer.cs (1)

73.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\PreferStreamAsyncMemoryOverloads.Fixer.cs (6)

121.WithTriviaFrom(bufferNode); 135namedStartNode.WithTriviaFrom(offsetNode), 136namedLengthNode.WithTriviaFrom(countNode)).WithAddImportsAnnotation().WithAdditionalAnnotations(s_asMemorySymbolAnnotation); 140.WithTriviaFrom(bufferNode); 153nodeArguments = new SyntaxNode[] { replacedInvocationNode, namedCancellationTokenNode.WithTriviaFrom(currentCancellationTokenNode) }; 160return generator.InvocationExpression(asyncMethodNode, nodeArguments).WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\PreferStringContainsOverIndexOf.Fixer.cs (1)

115return newIfCondition.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\TestForEmptyStringsUsingStringLength.Fixer.cs (2)

155return replacementSyntax.WithAdditionalAnnotations(Formatter.Annotation).WithTriviaFrom(currentNode); 180rightOperand = zeroLengthSyntax.WithTriviaFrom(rightOperand);

Microsoft.NetCore.Analyzers\Runtime\UseCancellationTokenThrowIfCancellationRequested.Fixer.cs (1)

131result = firstWhenTrueStatement is not null ? result.WithTriviaFrom(firstWhenTrueStatement.Syntax) : result;

Microsoft.NetCore.Analyzers\Runtime\UseEnvironmentMembersFixer.cs (1)

87editor.ReplaceNode(node, replacement.WithTriviaFrom(node));

Microsoft.NetCore.Analyzers\Runtime\UseExceptionThrowHelpersFixer.cs (1)

122other is not null ? new SyntaxNode[] { arg, other } : new SyntaxNode[] { arg })).WithTriviaFrom(node));

Microsoft.NetCore.Analyzers\Runtime\UseRegexMembersFixer.cs (1)

109.WithTriviaFrom(currentNode);

Microsoft.NetCore.Analyzers\Runtime\UseSpanBasedStringConcat.Fixer.cs (1)

179var stringLiteral = generator.LiteralExpression(literalValue.ToString()).WithTriviaFrom(current(literalOperation.Syntax));

Microsoft.NetCore.Analyzers\Tasks\DoNotUseWhenAllOrWaitAllWithSingleArgumentFixer.cs (2)

51).WithTriviaFrom(nodeToFix) 66var newNode = GetSingleArgumentSyntax(operation).WithTriviaFrom(nodeToFix);

Microsoft.NetCore.Analyzers\Usage\UseVolatileReadWrite.Fixer.cs (1)

87return currentGenerator.InvocationExpression(methodExpression, arguments).WithTriviaFrom(currentNode);

Microsoft.CodeAnalysis.Razor.Compiler (1)

CSharp\GlobalQualifiedTypeNameRewriter.cs (1)

69.WithTriviaFrom(node);

Microsoft.CodeAnalysis.VisualBasic.NetAnalyzers (13)

Microsoft.NetCore.Analyzers\Performance\BasicDoNotGuardCall.Fixer.vb (4)

51Return guardedStatement.WithAdditionalAnnotations(Formatter.Annotation).WithTriviaFrom(currentConditional) 60.WithAdditionalAnnotations(Formatter.Annotation).WithTriviaFrom(currentConditional) 76Return singleLineGuardedStatement.WithAdditionalAnnotations(Formatter.Annotation).WithTriviaFrom(currentConditional) 84.WithAdditionalAnnotations(Formatter.Annotation).WithTriviaFrom(currentConditional)

Microsoft.NetCore.Analyzers\Performance\BasicPreferDictionaryTryMethodsOverContainsKeyGuardFixer.vb (1)

240Dim invocationWithTrivia = tryAddInvocation.WithTriviaFrom(ifStatement)

Microsoft.NetCore.Analyzers\Performance\BasicPreferLengthCountIsEmptyOverAnyFixer.vb (3)

54Return newMemberAccess.WithTriviaFrom(currentNode) 61).WithTriviaFrom(currentNode) 87).WithTriviaFrom(currentNode)

Microsoft.NetCore.Analyzers\Performance\BasicRecommendCaseInsensitiveStringComparisonFixer.vb (1)

127arguments.Add(newArgumentNode.WithTriviaFrom(arg.Syntax))

Microsoft.NetCore.Analyzers\Runtime\BasicUseSpanBasedStringConcat.Fixer.vb (1)

21Dim newNameSyntax = generator.IdentifierName(newName).WithTriviaFrom(oldNameSyntax)

Microsoft.NetCore.Analyzers\Usage\BasicPreferGenericOverloads.Fixer.vb (2)

63.WithTriviaFrom(castExpressionSyntax)) _ 69.WithTriviaFrom(castExpressionSyntax))

Microsoft.NetCore.Analyzers\Usage\BasicPreferGenericOverloads.vb (1)

55.WithTriviaFrom(invocationSyntax)

Microsoft.CodeAnalysis.Workspaces (8)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (8)

Microsoft.ML.InternalCodeAnalyzer (2)

ContractsCheckNameofFixProvider.cs (2)

169var nameofExp = SyntaxFactory.ParseExpression($"nameof({name})").WithTriviaFrom(nameArg); 178var nameofExp = (InvocationExpressionSyntax)SyntaxFactory.ParseExpression($"nameof(a)").WithTriviaFrom(nameArg);

Roslyn.Diagnostics.Analyzers (8)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (8)

Roslyn.Diagnostics.CSharp.Analyzers (7)

PreferNullLiteralCodeFixProvider.cs (2)

63type = SyntaxFactory.NullableType(type.WithoutTrivia()).WithTriviaFrom(type); 76newSyntax = newSyntax.WithTriviaFrom(syntax);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

177SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (3)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

127IdentifierName(fieldOrProperty.Name.EscapeIdentifier()).WithTriviaFrom(identifierName));