Options

278 references to Options

dotnet-format (1)

Utilities\GeneratedCodeUtilities.cs (1)

29var isCommentTrivia = syntaxTree.Options.Language == LanguageNames.CSharp

GenerateDocumentationAndConfigFiles (9)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

245var info = GetInfo(context.Context, codeGenOptions, destinationDeclaration.SyntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

465var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)

85factory, generatorInternal, semanticModel.Compilation, semanticModel.SyntaxTree.Options, containingType, symbols);

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

63var options = semanticModel.SyntaxTree.Options; 182else if (operation is IIsTypeOperation { TypeOperand.SpecialType: SpecialType.System_Object } && generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)) 187else if (syntaxFacts.IsIsTypeExpression(expressionNode) && syntaxFacts.SupportsNotPattern(semanticModel.SyntaxTree.Options)) 266if (syntaxFacts.SupportsNotPattern(semanticModel.SyntaxTree.Options)) 561if (syntaxFacts.SupportsNotPattern(pattern.SyntaxTree.Options) &&

Microsoft.CodeAnalysis (6)

Compilation\Compilation.cs (3)

104var treeFeatures = tree.Options.Features; 1097Debug.Assert(tree.Options.Kind != SourceCodeKind.Script); 2616return tree.Options.DocumentationMode != DocumentationMode.None;

Compilation\DeterministicKey.cs (1)

42=> _tree.Options;

SourceGeneration\GeneratorState.cs (1)

129internal bool RequiresPostInitReparse(ParseOptions parseOptions) => PostInitTrees.Any(static (t, parseOptions) => t.Tree.Options != parseOptions, parseOptions);

Syntax\SyntaxNodeExtensions.cs (1)

447return node != null ? oldTree.WithRootAndOptions(node, oldTree.Options).GetRoot() : null;

Microsoft.CodeAnalysis.Analyzers (9)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

245var info = GetInfo(context.Context, codeGenOptions, destinationDeclaration.SyntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

465var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)

85factory, generatorInternal, semanticModel.Compilation, semanticModel.SyntaxTree.Options, containingType, symbols);

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

Microsoft.CodeAnalysis.AnalyzerUtilities (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

Microsoft.CodeAnalysis.CodeStyle (18)

src\roslyn\src\Analyzers\Core\Analyzers\AnalyzerOptionsProvider.cs (1)

88=> new(analyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree).GetOptionsReader(), syntaxTree.Options.Language);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

133if (tree is null || tree.Options.DocumentationMode != DocumentationMode.None)

src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (4)

265if (!this.SyntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options)) 281if (!this.SyntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options)) 384if (this.SyntaxFacts.SupportsFieldExpression(propertyDeclaration.SyntaxTree.Options) && 556if (!this.SyntaxFacts.SupportsFieldExpression(result.PropertyDeclaration.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullCheckDiagnosticAnalyzer.cs (1)

77if (!syntaxFacts.SupportsThrowExpression(ifStatement.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (3)

129if (initializerElementCount != 2 || !this.SyntaxFacts.SupportsKeyValuePairElement(_objectCreationExpression.SyntaxTree.Options)) 138if (_analyzeForCollectionExpression && seenIndexAssignment && !this.SyntaxFacts.SupportsKeyValuePairElement(_objectCreationExpression.SyntaxTree.Options)) 206return new(expressionStatement, UseSpread: false, UseKeyValue: this.State.SyntaxFacts.SupportsKeyValuePairElement(statement.SyntaxTree.Options));

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (4)

196this.SyntaxFacts.SupportsKeyValuePairElement(invocationExpression.SyntaxTree.Options) && 362if (!this.SyntaxFacts.SupportsIndexingInitializer(statement.SyntaxTree.Options)) 439if (@this.SyntaxFacts.SupportsKeyValuePairElement(expression.SyntaxTree.Options) && 514return @this.SyntaxFacts.SupportsCollectionExpressionNaturalType(ifStatement.SyntaxTree.Options)

src\roslyn\src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (1)

106if (!IsSupported(binaryKind, syntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (1)

106if (!syntaxFacts.SupportsThrowExpression(anyThrow.Syntax.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (1)

444syntaxFacts.SupportsNullConditionalAssignment(node.SyntaxTree.Options))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

Microsoft.CodeAnalysis.CodeStyle.Fixes (11)

src\roslyn\src\Analyzers\Core\CodeFixes\ConvertTypeOfToNameOf\AbstractConvertTypeOfToNameOfCodeFixProvider.cs (1)

60ConvertToUnboundGeneric(semanticModel.SyntaxTree.Options, nameOfSyntax));

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (1)

80compilation, tree.Options, unimplementedMembers, Options.PropertyGenerationBehavior);

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

40var title = GetTitle(negated, diagnostic.Location.SourceTree!.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

245var info = GetInfo(context.Context, codeGenOptions, destinationDeclaration.SyntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

465var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)

85factory, generatorInternal, semanticModel.Compilation, semanticModel.SyntaxTree.Options, containingType, symbols);

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

Microsoft.CodeAnalysis.CSharp (51)

Binder\Binder_Initializers.cs (1)

195Debug.Assert(syntaxTree.Options.Kind != SourceCodeKind.Regular);

Binder\Binder_Operators.cs (2)

4859((CSharpParseOptions)node.SyntaxTree.Options).IsFeatureEnabled(MessageID.IDS_FeaturePatternMatching)) 4954if (wasUnderscore && ((CSharpParseOptions)node.SyntaxTree.Options).IsFeatureEnabled(MessageID.IDS_FeatureRecursivePatterns))

Binder\Binder_Patterns.cs (1)

1512Debug.Assert(designation.SyntaxTree.Options.Kind != SourceCodeKind.Regular);

Binder\Binder_Statements.cs (1)

1294bool extensibleFixedEnabled = ((CSharpParseOptions)initializerOpt.SyntaxTree.Options)?.IsFeatureEnabled(MessageID.IDS_FeatureExtensibleFixedStatement) != false;

Binder\Binder_Symbols.cs (1)

2846if (feature.GetFeatureAvailabilityDiagnosticInfo((CSharpParseOptions)tree.Options) is { } diagInfo)

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

441if (node.Parent.Kind() == SyntaxKind.CompilationUnit && syntaxTree.Options.Kind != SourceCodeKind.Regular)

Binder\BinderFactory.cs (1)

94return _syntaxTree.Options.Kind == SourceCodeKind.Script;

Binder\SwitchBinder.cs (1)

36((CSharpParseOptions)SwitchSyntax.SyntaxTree.Options)?.IsFeatureEnabled(MessageID.IDS_FeaturePatternMatching) != false;

Compilation\CSharpCompilation.cs (5)

622var version = ((CSharpParseOptions)tree.Options).LanguageVersion; 3078if (!syntaxTree.Options.Errors.IsDefaultOrEmpty && parseOptionsReported.Add(syntaxTree.Options)) 3081foreach (var error in syntaxTree.Options.Errors) 4908bool value = SyntaxTrees.FirstOrDefault()?.Options?.HasFeature(CodeAnalysis.Feature.NullablePublicOnly) == true;

Compilation\CSharpCompilationExtensions.cs (1)

19return ((CSharpParseOptions?)syntax?.SyntaxTree.Options)?.IsFeatureEnabled(feature) == true;

Compilation\SyntaxAndDeclarationManager.cs (3)

167var sourceCodeKind = tree.Options.Kind; 243tree.Options, // Use ParseOptions propagated from "external" tree. 681var sourceCodeKind = tree.Options.Kind;

Compilation\SyntaxTreeSemanticModel.cs (2)

1299return this.SyntaxTree.Options.Kind == SourceCodeKind.Regular; 2364if (this.SyntaxTree.Options.Kind != SourceCodeKind.Regular)

Compiler\DocumentationCommentCompiler.cs (1)

835DocumentationMode currDocumentationMode = reference.SyntaxTree.Options.DocumentationMode;

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (1)

104Debug.Assert(sourceIncludeElementNodes.All(syntax => syntax.SyntaxTree.Options.DocumentationMode < DocumentationMode.Diagnose),

Declarations\DeclarationTreeBuilder.cs (5)

132(node.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind == SourceCodeKind.Regular)); 142bool acceptSimpleProgram = node.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind == SourceCodeKind.Regular; 268Debug.Assert(_syntaxTree.Options.Kind != SourceCodeKind.Regular); 328Debug.Assert(parent.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind != SourceCodeKind.Regular); 394if (_syntaxTree.Options.Kind != SourceCodeKind.Regular)

DocumentationComments\SourceDocumentationCommentUtils.cs (1)

35if (syntaxNode.SyntaxTree.Options.DocumentationMode < DocumentationMode.Parse)

Errors\MessageID.cs (4)

374syntax.SyntaxTree.Options, 388syntax.SyntaxTree!.Options, 402syntax.SyntaxTree.Options, 416syntax.SyntaxTree!.Options,

Symbols\Source\LocalFunctionSymbol.cs (1)

428var diagnosticInfo = MessageID.IDS_FeatureLocalFunctionAttributes.GetFeatureAvailabilityDiagnosticInfo((CSharpParseOptions)syntaxReferenceOpt.SyntaxTree.Options);

Symbols\Source\ModifierUtils.cs (4)

125if (MessageID.IDS_FeatureRefFields.GetFeatureAvailabilityDiagnosticInfo((CSharpParseOptions)syntax.SyntaxTree.Options) is { } diagnosticInfo) 156LanguageVersion availableVersion = ((CSharpParseOptions)errorLocation.SourceTree.Options).LanguageVersion; 220LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion; 234LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion;

Symbols\Source\SourceMemberContainerSymbol.cs (1)

5300var languageVersion = ((CSharpParseOptions)this.GetFirstLocation().SourceTree!.Options).LanguageVersion;

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

1043var interceptorsNamespaces = ((CSharpParseOptions)attributeNameSyntax.SyntaxTree.Options).InterceptorsNamespaces; 1180var interceptorsNamespaces = ((CSharpParseOptions)attributeSyntax.SyntaxTree.Options).InterceptorsNamespaces;

Symbols\Source\SourceModuleSymbol.cs (2)

375ImmutableArray<ImmutableArray<string>> interceptorsNamespaces = ((CSharpParseOptions)location.SourceTree.Options).InterceptorsNamespaces; 639var options = (CSharpParseOptions?)compilation.SyntaxTrees.FirstOrDefault()?.Options;

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

506var options = (CSharpParseOptions)SyntaxTree.Options;

Symbols\Source\SourcePropertySymbol.cs (2)

53((CSharpParseOptions)syntax.SyntaxTree.Options).IsFeatureEnabled(MessageID.IDS_FeatureFieldKeyword)); 462LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion;

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (1)

246LanguageVersion availableVersion = ((CSharpParseOptions)location.SourceTree.Options).LanguageVersion;

Symbols\Symbol_Attributes.cs (1)

709var parseOptions = (CSharpParseOptions)targetOpt.SyntaxTree.Options;

Syntax\SyntaxExtensions.cs (1)

179return tree.Options.DocumentationMode >= DocumentationMode.Diagnose;

Syntax\SyntaxFactory.cs (2)

2369if (tree.Options.Kind != SourceCodeKind.Script) 2427if (tree.Options.Kind == SourceCodeKind.Regular ||

Syntax\SyntaxFacts.cs (1)

540return IsTopLevelStatement(syntax) && syntax.SyntaxTree.Options.Kind == SourceCodeKind.Regular;

Microsoft.CodeAnalysis.CSharp.CodeStyle (20)

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertNamespaceAnalysis.cs (1)

41=> CanOfferUseFileScoped(option, root, declaration, forAnalyzer, root.SyntaxTree.Options.LanguageVersion());

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

36var analyzer = new Analyzer(supportsOrPatterns: semanticModel.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9);

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

66var csOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (1)

51if (ifStatement.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp6)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (1)

88originalTree.Options);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (1)

103originalTree.Options);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnusedParametersAndValues\CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs (1)

30=> tree.Options.LanguageVersion() >= LanguageVersion.CSharp7;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (2)

64this.SyntaxFacts.SupportsKeyValuePairElement(_objectCreationExpression.SyntaxTree.Options)) 89var supportsWithArgument = _objectCreationExpression.SyntaxTree.Options.LanguageVersion().IsCSharp15OrAbove();

src\roslyn\src\Analyzers\CSharp\Analyzers\UseDefaultLiteral\CSharpUseDefaultLiteralDiagnosticAnalyzer.cs (1)

40var parseOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBody\Helpers\UseExpressionBodyHelper`1.cs (1)

133var languageVersion = body.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaHelpers.cs (1)

56var languageVersion = declaration.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs (1)

41if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs (1)

40var parseOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

132var options = semanticModel.SyntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternCombinators\CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs (1)

59if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (1)

61if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

513var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

26=> ((CSharpParseOptions)node.SyntaxTree.Options).LanguageVersion;

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

179var newTree = tree.WithRootAndOptions(newRoot, tree.Options);

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

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

70if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(root.SyntaxTree.Options.LanguageVersion()))

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

100parent.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9)

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

49var parseOptions = (CSharpParseOptions)originalRoot.SyntaxTree.Options;

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

42var title = GetTitle(negated, diagnostic.Location.SourceTree!.Options); 71if (SupportsIsNotPattern(binary.SyntaxTree.Options))

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

41if (SupportsIsNotPattern(argument.SyntaxTree.Options))

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

86var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();

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

48var languageVersion = tree.Options.LanguageVersion();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (1)

84var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

412=> IsGlobalStatementContext && SyntaxTree.Options.Kind is SourceCodeKind.Regular;

Microsoft.CodeAnalysis.CSharp.Features (43)

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

133var supportsNonTrailing = SupportsNonTrailingNamedArguments(root.SyntaxTree.Options);

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (2)

56if (root.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9) 384if (names.Length > 1 && names[0].SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp10)

Completion\CompletionProviders\FileBasedPrograms\AbstractAppDirectiveCompletionProvider.cs (1)

47if (!tree.Options.Features.ContainsKey("FileBasedProgram"))

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (2)

251var parsed = (InterpolatedStringExpressionSyntax)ParseExpression(indentedText.ToString(), options: stringExpression.SyntaxTree.Options); 631var parsed = (InterpolatedStringExpressionSyntax)ParseExpression(builder.ToString(), options: stringExpression.SyntaxTree.Options);

Copilot\CSharpCopilotCodeFixProvider.cs (1)

106var memberDeclaration = SyntaxFactory.ParseMemberDeclaration(fix, options: method.SyntaxTree.Options);

Diagnostics\Analyzers\FileBasedPrograms\FileLevelDirectiveDiagnosticAnalyzer.cs (1)

41if (!tree.Options.Features.ContainsKey("FileBasedProgram"))

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (2)

300=> node.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp8; 361var languageVersion = SemanticDocument.SyntaxTree.Options.LanguageVersion();

ExtractMethod\CSharpSelectionValidator.cs (1)

81selectionInfo = ApplySpecialCases(initialSelectionInfo, selectionInfo, SemanticDocument.SyntaxTree.Options, _localFunction);

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (1)

59document.Root.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9)

MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeRefactoringProvider.cs (1)

30if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(syntaxTree.Options.LanguageVersion()))

MetadataAsSource\CSharpMetadataAsSourceService.cs (1)

104var options = (CSharpParseOptions)tree.Options;

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

188if (semanticModel.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp8)

ReplacePropertyWithMethods\CSharpReplacePropertyWithMethodsService.cs (1)

49var languageVersion = syntaxTree.Options.LanguageVersion();

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertNamespaceAnalysis.cs (1)

41=> CanOfferUseFileScoped(option, root, declaration, forAnalyzer, root.SyntaxTree.Options.LanguageVersion());

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

36var analyzer = new Analyzer(supportsOrPatterns: semanticModel.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9);

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

66var csOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (1)

51if (ifStatement.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp6)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (1)

88originalTree.Options);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (1)

103originalTree.Options);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnusedParametersAndValues\CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs (1)

30=> tree.Options.LanguageVersion() >= LanguageVersion.CSharp7;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (2)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseDefaultLiteral\CSharpUseDefaultLiteralDiagnosticAnalyzer.cs (1)

40var parseOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBody\Helpers\UseExpressionBodyHelper`1.cs (1)

133var languageVersion = body.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaHelpers.cs (1)

56var languageVersion = declaration.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs (1)

41if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs (1)

40var parseOptions = (CSharpParseOptions)syntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

132var options = semanticModel.SyntaxTree.Options;

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternCombinators\CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs (1)

59if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (1)

61if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7)

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

70if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(root.SyntaxTree.Options.LanguageVersion()))

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

100parent.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9)

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

49var parseOptions = (CSharpParseOptions)originalRoot.SyntaxTree.Options;

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

42var title = GetTitle(negated, diagnostic.Location.SourceTree!.Options); 71if (SupportsIsNotPattern(binary.SyntaxTree.Options))

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

41if (SupportsIsNotPattern(argument.SyntaxTree.Options))

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

86var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();

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

48var languageVersion = tree.Options.LanguageVersion();

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (2)

71if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7) 243changedRoot, semanticModel.SyntaxTree.Options);

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (2)

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

57if (root.SyntaxTree.Options is CSharpParseOptions parseOptions &&

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler.CSharp\Extensions\SyntaxGeneratorExtensions.cs (1)

39if ((left.SyntaxTree.Options is not CSharpParseOptions csharpParseOptions) || (csharpParseOptions.LanguageVersion < CSharp11))

Microsoft.CodeAnalysis.CSharp.Workspaces (7)

EmbeddedLanguages\CSharpTestEmbeddedLanguageUtilities.cs (1)

25var testFileTree = SyntaxFactory.ParseSyntaxTree(testFileSourceText, semanticModel.SyntaxTree.Options, cancellationToken: cancellationToken);

FindSymbols\FindSymbolsUtilities.cs (1)

46if (((CSharpParseOptions)container.SyntaxTree.Options).Kind == SourceCodeKind.Script)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

513var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

26=> ((CSharpParseOptions)node.SyntaxTree.Options).LanguageVersion;

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

179var newTree = tree.WithRootAndOptions(newRoot, tree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (1)

84var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

412=> IsGlobalStatementContext && SyntaxTree.Options.Kind is SourceCodeKind.Regular;

Microsoft.CodeAnalysis.Features (43)

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (1)

48var language = diagnostic.Location.SourceTree.Options.Language;

CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs (1)

99if (!syntaxFacts.SupportsLocalFunctionDeclaration(syntaxTree.Options))

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

37preprocessorNames.AddRange(currentSyntaxTree.Options.PreprocessorSymbolNames);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (1)

61if (syntaxFacts.SupportsRecord(anonymousObject.SyntaxTree.Options))

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

58if (syntaxFacts.SupportsFieldExpression(semanticModel.SyntaxTree.Options) &&

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (1)

96analyzer = CreateAnalyzer(syntaxFactsService, ifStatement.SyntaxTree.Options);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

39var options = root.SyntaxTree.Options;

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

91if (syntaxFacts.SupportsRecordStruct(syntaxTree.Options))

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

581if (GetParseOptionsRudeEdits(oldTree.Options, newTree.Options).Any()) 766oldRoot ??= GetEmptyRoot(newRoot!.SyntaxTree.Options); 767newRoot ??= GetEmptyRoot(oldRoot.SyntaxTree.Options);

ExtractMethod\Extensions.cs (1)

68return node.SyntaxTree.Options.Kind != SourceCodeKind.Regular;

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (2)

47generatorInternal, compilation, tree.Options, namedType, members, localNameOpt, s_specializedFormattingAnnotation); 72if (generator.SyntaxGeneratorInternal.SupportsPatterns(tree.Options))

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (1)

901if (!syntaxFacts.SupportsThrowExpression(syntaxTree.Options))

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (2)

509codeGenerator.GetInfo(GetAddContext<IPropertySymbol>(parameter, blockStatement, typeDeclaration, cancellationToken), options, root.SyntaxTree.Options), 516codeGenerator.GetInfo(GetAddContext<IFieldSymbol>(parameter, blockStatement, typeDeclaration, cancellationToken), options, root.SyntaxTree.Options),

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

191this.TryCreateUsingLocalDeclaration(root.SyntaxTree.Options, declarationStatement, out var usingDeclarationStatement))

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (1)

51if (type.IsTupleType && syntaxFacts.SupportsTupleDeconstruction(expression.SyntaxTree.Options))

QuickInfo\CommonSemanticQuickInfoProvider.cs (1)

255var newTree = semanticModel.SyntaxTree.WithRootAndOptions(newRoot, semanticModel.SyntaxTree.Options);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

367var parseOptions = syntaxTree.Options;

src\roslyn\src\Analyzers\Core\Analyzers\AnalyzerOptionsProvider.cs (1)

88=> new(analyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree).GetOptionsReader(), syntaxTree.Options.Language);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

133if (tree is null || tree.Options.DocumentationMode != DocumentationMode.None)

src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (4)

src\roslyn\src\Analyzers\Core\Analyzers\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullCheckDiagnosticAnalyzer.cs (1)

77if (!syntaxFacts.SupportsThrowExpression(ifStatement.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (3)

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (4)

src\roslyn\src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (1)

106if (!IsSupported(binaryKind, syntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (1)

106if (!syntaxFacts.SupportsThrowExpression(anyThrow.Syntax.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (1)

444syntaxFacts.SupportsNullConditionalAssignment(node.SyntaxTree.Options))

src\roslyn\src\Analyzers\Core\CodeFixes\ConvertTypeOfToNameOf\AbstractConvertTypeOfToNameOfCodeFixProvider.cs (1)

60ConvertToUnboundGeneric(semanticModel.SyntaxTree.Options, nameOfSyntax));

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (1)

80compilation, tree.Options, unimplementedMembers, Options.PropertyGenerationBehavior);

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

40var title = GetTitle(negated, diagnostic.Location.SourceTree!.Options);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

107if (SupportsNonTrailingNamedArguments(root.SyntaxTree.Options) &&

Microsoft.CodeAnalysis.Razor.Compiler (1)

CSharp\DefaultUtf8WriteLiteralFeature.cs (1)

181var parseOptions = compilation.SyntaxTrees.FirstOrDefault()?.Options as CSharpParseOptions

Microsoft.CodeAnalysis.ResxSourceGenerator (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

Microsoft.CodeAnalysis.VisualBasic (13)

Binding\Binder_Invocation.vb (1)

2904DirectCast(argument.Syntax.SyntaxTree.Options, VisualBasicParseOptions).LanguageVersion,

Binding\Binder_Statements.vb (1)

1966DirectCast(node.SyntaxTree.Options, VisualBasicParseOptions).LanguageVersion,

Binding\BinderFactory.vb (2)

36Return _tree.Options.Kind = SourceCodeKind.Script 165If node.Kind <> SyntaxKind.CompilationUnit OrElse _tree.Options.Kind = SourceCodeKind.Regular Then

Compilation\VisualBasicCompilation.vb (4)

493Dim version = CType(tree.Options, VisualBasicParseOptions).LanguageVersion 2180If Not tree.Options.Errors.IsDefaultOrEmpty AndAlso parseOptionsReported.Add(tree.Options) Then 2182For Each err In tree.Options.Errors

Declarations\DeclarationTreeBuilder.vb (2)

132Debug.Assert(parent.Kind = SyntaxKind.CompilationUnit AndAlso _syntaxTree.Options.Kind <> SourceCodeKind.Regular) 175If _syntaxTree.Options.Kind <> SourceCodeKind.Regular Then

Symbols\ConstraintsHelper.vb (1)

469DirectCast(syntaxNode.SyntaxTree.Options, VisualBasicParseOptions).LanguageVersion,

Syntax\SyntaxExtensions.vb (1)

15Return tree.Options.DocumentationMode >= DocumentationMode.Diagnose

Syntax\SyntaxFactory.vb (1)

1067Dim options As VisualBasicParseOptions = DirectCast(tree.Options, VisualBasicParseOptions)

Microsoft.CodeAnalysis.VisualBasic.CodeStyle (3)

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseInferredMemberName\VisualBasicUseInferredMemberNameDiagnosticAnalyzer.vb (1)

47Not CanSimplifyTupleName(argument, DirectCast(syntaxTree.Options, VisualBasicParseOptions)) Then

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseIsNotExpression\VisualBasicUseIsNotDiagnosticAnalyzer.vb (1)

48If DirectCast(syntaxTree.Options, VisualBasicParseOptions).LanguageVersion < LanguageVersion.VisualBasic14 Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

75Dim updatedSyntaxTree = model.SyntaxTree.WithRootAndOptions(updatedRoot, model.SyntaxTree.Options)

Microsoft.CodeAnalysis.VisualBasic.Features (2)

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseInferredMemberName\VisualBasicUseInferredMemberNameDiagnosticAnalyzer.vb (1)

47Not CanSimplifyTupleName(argument, DirectCast(syntaxTree.Options, VisualBasicParseOptions)) Then

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseIsNotExpression\VisualBasicUseIsNotDiagnosticAnalyzer.vb (1)

48If DirectCast(syntaxTree.Options, VisualBasicParseOptions).LanguageVersion < LanguageVersion.VisualBasic14 Then

Microsoft.CodeAnalysis.VisualBasic.Workspaces (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

75Dim updatedSyntaxTree = model.SyntaxTree.WithRootAndOptions(updatedRoot, model.SyntaxTree.Options)

Microsoft.CodeAnalysis.Workspaces (11)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

245var info = GetInfo(context.Context, codeGenOptions, destinationDeclaration.SyntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

465var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)

85factory, generatorInternal, semanticModel.Compilation, semanticModel.SyntaxTree.Options, containingType, symbols);

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

Workspace\Solution\DocumentState_LinkedFileReuse.cs (1)

193var siblingParseOptions = siblingTree.Options;

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker_Generators.cs (1)

397generatedSource.SyntaxTree.Options,

Microsoft.Interop.LibraryImportGenerator (1)

Analyzers\ConvertToLibraryImportFixer.cs (1)

643if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp12)

Roslyn.Diagnostics.Analyzers (9)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (1)

39=> syntaxTree.Options.Kind != SourceCodeKind.Regular;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

245var info = GetInfo(context.Context, codeGenOptions, destinationDeclaration.SyntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

465var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)

85factory, generatorInternal, semanticModel.Compilation, semanticModel.SyntaxTree.Options, containingType, symbols);

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

Roslyn.Diagnostics.CSharp.Analyzers (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

513var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

26=> ((CSharpParseOptions)node.SyntaxTree.Options).LanguageVersion;

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

179var newTree = tree.WithRootAndOptions(newRoot, tree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (1)

84var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

412=> IsGlobalStatementContext && SyntaxTree.Options.Kind is SourceCodeKind.Regular;