Merge pull request #33647 from CyrusNajmabadi/whenExplicit

Rename and cleanup some members in the 'use var' feature.

src/EditorFeatures/CSharpTest/CodeActions/ExtractMethod/ExtractMethodTests.cs

@@ -1423,7 +1423,7 @@ private static string NewMethod(int i)
 
         return v;
     }
-}", options: Option(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSuggestionEnforcement));
+}", options: Option(CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSuggestionEnforcement));
         }
 
         [WorkItem(15219, "https://github.com/dotnet/roslyn/issues/15219")]
@@ -1471,7 +1471,7 @@ private static string NewMethod(int i)
 
         return v;
     }
-}", options: Option(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSuggestionEnforcement));
+}", options: Option(CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSuggestionEnforcement));
         }
 
         [Fact]

src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs

@@ -31,9 +31,9 @@ protected override ImmutableArray<CodeAction> MassageActions(ImmutableArray<Code
         // specify all options explicitly to override defaults.
         private IDictionary<OptionKey, object> ImplicitTypingEverywhere() =>
             OptionsSet(
-                SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-                SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-                SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+                SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+                SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+                SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         internal IDictionary<OptionKey, object> OptionSet(OptionKey option, object value)
         {

src/EditorFeatures/CSharpTest/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeRefactoringTests.cs

@@ -21,53 +21,53 @@ public abstract class AbstractUseTypeRefactoringTests : AbstractCSharpCodeAction
         private readonly CodeStyleOption<bool> onWithError = new CodeStyleOption<bool>(true, NotificationOption.Error);
 
         protected IDictionary<OptionKey, object> PreferExplicitTypeWithError() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithError));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithError),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithError));
 
         protected IDictionary<OptionKey, object> PreferImplicitTypeWithError() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithError));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithError),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithError));
 
         protected IDictionary<OptionKey, object> PreferExplicitTypeWithWarning() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithWarning));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithWarning));
 
         protected IDictionary<OptionKey, object> PreferImplicitTypeWithWarning() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithWarning));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithWarning));
 
         protected IDictionary<OptionKey, object> PreferExplicitTypeWithInfo() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         protected IDictionary<OptionKey, object> PreferImplicitTypeWithInfo() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         protected IDictionary<OptionKey, object> PreferExplicitTypeWithSilent() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent));
 
         protected IDictionary<OptionKey, object> PreferImplicitTypeWithSilent() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
 
         protected IDictionary<OptionKey, object> PreferExplicitTypeWithNone() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithNone),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithNone),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithNone));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithNone),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithNone),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithNone));
 
         protected IDictionary<OptionKey, object> PreferImplicitTypeWithNone() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithNone),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithNone),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithNone));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithNone),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithNone),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithNone));
     }
 }

src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs

@@ -23,9 +23,9 @@ public partial class ConvertForEachToForTests : AbstractCSharpCodeActionTest
         private readonly CodeStyleOption<bool> onWithSilent = new CodeStyleOption<bool>(true, NotificationOption.Silent);
 
         private IDictionary<OptionKey, object> ImplicitTypeEverywhere => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForEachToFor)]
         public async Task EmptyBlockBody()

src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs

@@ -21,9 +21,9 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa
         private readonly CodeStyleOption<bool> onWithSilent = new CodeStyleOption<bool>(true, NotificationOption.Silent);
 
         private IDictionary<OptionKey, object> ImplicitTypeEverywhere() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForToForEach)]
         public async Task TestArray1()

src/EditorFeatures/CSharpTest/Diagnostics/UseImplicitOrExplicitType/UseExplicitTypeTests.cs

@@ -31,29 +31,29 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
 
         // specify all options explicitly to override defaults.
         private IDictionary<OptionKey, object> ExplicitTypeEverywhere() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         private IDictionary<OptionKey, object> ExplicitTypeExceptWhereApparent() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         private IDictionary<OptionKey, object> ExplicitTypeForBuiltInTypesOnly() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         private IDictionary<OptionKey, object> ExplicitTypeEnforcements() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         private IDictionary<OptionKey, object> ExplicitTypeSilentEnforcement() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, offWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent));
 
         private IDictionary<OptionKey, object> Options(OptionKey option, object value)
         {

src/EditorFeatures/CSharpTest/Diagnostics/UseImplicitOrExplicitType/UseImplicitTypeTests.cs

@@ -32,34 +32,34 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
 
         // specify all options explicitly to override defaults.
         public IDictionary<OptionKey, object> ImplicitTypeEverywhere() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         private IDictionary<OptionKey, object> ImplicitTypeWhereApparent() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
 
         private IDictionary<OptionKey, object> ImplicitTypeWhereApparentAndForIntrinsics() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         public IDictionary<OptionKey, object> ImplicitTypeButKeepIntrinsics() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, offWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo));
 
         private IDictionary<OptionKey, object> ImplicitTypeEnforcements() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithWarning),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithError),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         private IDictionary<OptionKey, object> ImplicitTypeSilentEnforcement() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
 
         private static IDictionary<OptionKey, object> Options(OptionKey option, object value)
             => new Dictionary<OptionKey, object> { { option, value } };

src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs

@@ -33,9 +33,9 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
 
         // specify all options explicitly to override defaults.
         private IDictionary<OptionKey, object> ImplicitTypingEverywhere() => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithInfo),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithInfo));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
 
         internal IDictionary<OptionKey, object> OptionSet(OptionKey option, object value)
         {

src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs

@@ -4016,9 +4016,9 @@ private async Task TestWithPredefinedTypeOptionsAsync(string code, string expect
             SingleOption(CodeStyleOptions.PreferIntrinsicPredefinedTypeKeywordInDeclaration, this.offWithSilent, GetLanguage()));
 
         private IDictionary<OptionKey, object> PreferImplicitTypeWithSilent => OptionsSet(
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, onWithSilent),
-            SingleOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, onWithSilent));
+            SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
+            SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
 
         private readonly CodeStyleOption<bool> onWithSilent = new CodeStyleOption<bool>(true, NotificationOption.Silent);
         private readonly CodeStyleOption<bool> offWithSilent = new CodeStyleOption<bool>(false, NotificationOption.Silent);

src/EditorFeatures/CSharpTest/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs

@@ -23,9 +23,9 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
 
         private static readonly Dictionary<OptionKey, object> s_preferImplicitTypeAlways = new Dictionary<OptionKey, object>
         {
-            { CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement },
-            { CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement },
-            { CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement },
+            { CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement },
+            { CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement },
+            { CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement },
         };
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseConditionalExpression)]
@@ -495,7 +495,7 @@ void M()
         var i = true ? 0 : 1;
     }
 }", options: new Dictionary<OptionKey, object> {
-    {  CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement }
+    {  CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement }
 });
         }
 
@@ -527,7 +527,7 @@ void M()
         int i = true ? 0 : 1;
     }
 }", options: new Dictionary<OptionKey, object> {
-    {  CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement }
+    {  CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement }
 });
         }
 
@@ -559,7 +559,7 @@ void M()
         int i = true ? 0 : 1;
     }
 }", options: new Dictionary<OptionKey, object> {
-    {  CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement }
+    {  CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement }
 });
         }
 

src/EditorFeatures/Test2/Simplification/TypeNameSimplifierTest.vb

@@ -1471,9 +1471,9 @@ class C1
         Public Async Function TestCSharpSimplifyToVarLocalDeclaration() As Task
             Dim simplificationOption = New Dictionary(Of OptionKey, Object) From {
                 {SimplificationOptions.PreferImplicitTypeInLocalDeclaration, True},
-                {CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement}
+                {CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement}
             }
 
             Dim input =
@@ -1510,9 +1510,9 @@ class Program
         Public Async Function TestCSharpSimplifyToVarForeachDecl() As Task
             Dim simplificationOption = New Dictionary(Of OptionKey, Object) From {
                 {SimplificationOptions.PreferImplicitTypeInLocalDeclaration, True},
-                {CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement}
+                {CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement}
             }
 
             Dim input =
@@ -1551,9 +1551,9 @@ class Program
         Public Async Function TestCSharpSimplifyToVarCorrect() As Task
             Dim simplificationOption = New Dictionary(Of OptionKey, Object) From {
                 {SimplificationOptions.PreferImplicitTypeInLocalDeclaration, True},
-                {CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement}
+                {CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement}
             }
 
             Dim input =
@@ -1622,9 +1622,9 @@ class Program
         Public Async Function TestCSharpSimplifyToVarCorrect_QualifiedTypeNames() As Task
             Dim simplificationOption = New Dictionary(Of OptionKey, Object) From {
                 {SimplificationOptions.PreferImplicitTypeInLocalDeclaration, True},
-                {CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CodeStyleOptions.TrueWithSilentEnforcement},
-                {CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CodeStyleOptions.TrueWithSilentEnforcement}
+                {CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions.TrueWithSilentEnforcement},
+                {CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions.TrueWithSilentEnforcement}
             }
 
             Dim input =

src/Features/CSharp/Portable/Diagnostics/Analyzers/CSharpTypeStyleDiagnosticAnalyzerBase.cs

@@ -24,9 +24,9 @@ internal abstract partial class CSharpTypeStyleDiagnosticAnalyzerBase :
 
         public override bool OpenFileOnly(Workspace workspace)
         {
-            var forIntrinsicTypesOption = workspace.Options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes).Notification;
-            var whereApparentOption = workspace.Options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent).Notification;
-            var wherePossibleOption = workspace.Options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible).Notification;
+            var forIntrinsicTypesOption = workspace.Options.GetOption(CSharpCodeStyleOptions.VarForBuiltInTypes).Notification;
+            var whereApparentOption = workspace.Options.GetOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent).Notification;
+            var wherePossibleOption = workspace.Options.GetOption(CSharpCodeStyleOptions.VarElsewhere).Notification;
 
             return !(forIntrinsicTypesOption == NotificationOption.Warning || forIntrinsicTypesOption == NotificationOption.Error ||
                      whereApparentOption == NotificationOption.Warning || whereApparentOption == NotificationOption.Error ||

src/Features/CSharp/Portable/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs

@@ -260,11 +260,11 @@ private static bool IsVarDesired(ITypeSymbol type, OptionSet options)
             // If they want it for intrinsics, and this is an intrinsic, then use var.
             if (type.IsSpecialType() == true)
             {
-                return options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes).Value;
+                return options.GetOption(CSharpCodeStyleOptions.VarForBuiltInTypes).Value;
             }
 
             // If they want "var" whenever possible, then use "var".
-            return options.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible).Value;
+            return options.GetOption(CSharpCodeStyleOptions.VarElsewhere).Value;
         }
 
         private static DeclarationExpressionSyntax GetDeclarationExpression(

src/VisualStudio/CSharp/Impl/Options/AutomationObject.cs

@@ -643,20 +643,20 @@ public int Style_UseVarWhenDeclaringLocals
 
         public string Style_UseImplicitTypeWherePossible
         {
-            get { return GetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible); }
-            set { SetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, value); }
+            get { return GetXmlOption(CSharpCodeStyleOptions.VarElsewhere); }
+            set { SetXmlOption(CSharpCodeStyleOptions.VarElsewhere, value); }
         }
 
         public string Style_UseImplicitTypeWhereApparent
         {
-            get { return GetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent); }
-            set { SetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, value); }
+            get { return GetXmlOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent); }
+            set { SetXmlOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, value); }
         }
 
         public string Style_UseImplicitTypeForIntrinsicTypes
         {
-            get { return GetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes); }
-            set { SetXmlOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, value); }
+            get { return GetXmlOption(CSharpCodeStyleOptions.VarForBuiltInTypes); }
+            set { SetXmlOption(CSharpCodeStyleOptions.VarForBuiltInTypes, value); }
         }
 
         public string Style_PreferConditionalDelegateCall

src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs

@@ -1543,9 +1543,9 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, ServicesVSResources.For_member_access_expressions, s_intrinsicPreviewMemberAccessTrue, s_intrinsicPreviewMemberAccessFalse, this, optionStore, predefinedTypesGroupTitle, predefinedTypesPreferences));
 
             // Use var
-            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, CSharpVSResources.For_built_in_types, s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
-            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, CSharpVSResources.When_variable_type_is_apparent, s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
-            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.UseImplicitTypeWherePossible, CSharpVSResources.Elsewhere, s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.VarForBuiltInTypes, CSharpVSResources.For_built_in_types, s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.VarWhenTypeIsApparent, CSharpVSResources.When_variable_type_is_apparent, s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.VarElsewhere, CSharpVSResources.Elsewhere, s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionStore, varGroupTitle, typeStylePreferences));
 
             // Code block
             AddBracesOptions(optionStore, codeBlockPreferencesGroupTitle);

src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs

@@ -53,7 +53,7 @@ void Method()
                 Assert.Equal(DiagnosticSeverity.Hidden, diagnostics[0].Severity);
 
                 // set option
-                workspace.Options = workspace.Options.WithChangedOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion));
+                workspace.Options = workspace.Options.WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion));
                 analyzerResult = await AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType);
 
                 diagnostics = analyzerResult.SemanticLocals[analyzerResult.DocumentIds.First()];
@@ -179,7 +179,7 @@ void Method()
                     nameof(IRemoteHostService.SynchronizeGlobalAssetsAsync), (object)(new Checksum[] { asset.Checksum }), CancellationToken.None);
 
                 // set option
-                workspace.Options = workspace.Options.WithChangedOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion));
+                workspace.Options = workspace.Options.WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion));
 
                 // run analysis
                 var project = workspace.CurrentSolution.Projects.First();

src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs

@@ -17,22 +17,22 @@ internal static partial class CSharpCodeStyleOptions
         private static Option<T> CreateOption<T>(OptionGroup group, string name, T defaultValue, params OptionStorageLocation[] storageLocations)
             => CodeStyleHelpers.CreateOption(group, nameof(CSharpCodeStyleOptions), name, defaultValue, s_allOptionsBuilder, storageLocations);
 
-        public static readonly Option<CodeStyleOption<bool>> UseImplicitTypeForIntrinsicTypes = CreateOption(
-            CSharpCodeStyleOptionGroups.VarPreferences, nameof(UseImplicitTypeForIntrinsicTypes),
+        public static readonly Option<CodeStyleOption<bool>> VarForBuiltInTypes = CreateOption(
+            CSharpCodeStyleOptionGroups.VarPreferences, nameof(VarForBuiltInTypes),
             defaultValue: CodeStyleOption<bool>.Default,
             storageLocations: new OptionStorageLocation[] {
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_style_var_for_built_in_types"),
                 new RoamingProfileStorageLocation("TextEditor.CSharp.Specific.UseImplicitTypeForIntrinsicTypes")});
 
-        public static readonly Option<CodeStyleOption<bool>> UseImplicitTypeWhereApparent = CreateOption(
-            CSharpCodeStyleOptionGroups.VarPreferences, nameof(UseImplicitTypeWhereApparent),
+        public static readonly Option<CodeStyleOption<bool>> VarWhenTypeIsApparent = CreateOption(
+            CSharpCodeStyleOptionGroups.VarPreferences, nameof(VarWhenTypeIsApparent),
             defaultValue: CodeStyleOption<bool>.Default,
             storageLocations: new OptionStorageLocation[] {
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_style_var_when_type_is_apparent"),
                 new RoamingProfileStorageLocation("TextEditor.CSharp.Specific.UseImplicitTypeWhereApparent")});
 
-        public static readonly Option<CodeStyleOption<bool>> UseImplicitTypeWherePossible = CreateOption(
-            CSharpCodeStyleOptionGroups.VarPreferences, nameof(UseImplicitTypeWherePossible),
+        public static readonly Option<CodeStyleOption<bool>> VarElsewhere = CreateOption(
+            CSharpCodeStyleOptionGroups.VarPreferences, nameof(VarElsewhere),
             defaultValue: CodeStyleOption<bool>.Default,
             storageLocations: new OptionStorageLocation[] {
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_style_var_elsewhere"),
@@ -254,9 +254,9 @@ static CSharpCodeStyleOptions()
 
         public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
         {
-            yield return UseImplicitTypeForIntrinsicTypes;
-            yield return UseImplicitTypeWhereApparent;
-            yield return UseImplicitTypeWherePossible;
+            yield return VarForBuiltInTypes;
+            yield return VarWhenTypeIsApparent;
+            yield return VarElsewhere;
             yield return PreferConditionalDelegateCall;
             yield return PreferPatternMatchingOverAsWithNullCheck;
             yield return PreferPatternMatchingOverIsWithCastCheck;

src/Workspaces/CSharp/Portable/CodeStyle/TypeStyle/TypeStyle.cs

@@ -11,11 +11,11 @@
 namespace Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle
 {
     [Flags]
-    internal enum TypeStylePreference
+    internal enum UseVarPreference
     {
         None = 0,
-        ImplicitTypeForIntrinsicTypes = 1 << 0,
-        ImplicitTypeWhereApparent = 1 << 1,
-        ImplicitTypeWherePossible = 1 << 2,
+        ForBuiltInTypes = 1 << 0,
+        WhenTypeIsApparent = 1 << 1,
+        Elsewhere = 1 << 2,
     }
 }

src/Workspaces/CSharp/Portable/CodeStyle/TypeStyle/TypeStyleHelper.cs

@@ -5,7 +5,6 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
@@ -13,37 +12,6 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeStyle.TypeStyle
 {
     internal static class TypeStyleHelper
     {
-        /// <summary>
-        /// Given an expression or assignment, answers whether the declaration can use var keyword,
-        /// by looking at the user's style preferences obtained from options and the context
-        /// obtained from the expression.
-        /// </summary>
-        public static bool IsImplicitTypePreferred(
-            ExpressionSyntax initializerExpression,
-            SemanticModel semanticModel,
-            OptionSet optionSet,
-            CancellationToken cancellationToken)
-        {
-            var stylePreferences = GetCurrentTypeStylePreferences(optionSet);
-
-            var isBuiltInTypeContext = IsBuiltInType(initializerExpression, semanticModel, cancellationToken);
-
-            var isTypeApparentContext = IsTypeApparentInAssignmentExpression(
-                stylePreferences, initializerExpression, semanticModel, cancellationToken);
-
-            return IsImplicitStylePreferred(stylePreferences, isBuiltInTypeContext, isTypeApparentContext);
-        }
-
-        /// <summary>
-        /// Given an expression of assignment, answers if its type is
-        /// considered an intrinsic predefined type.
-        /// </summary>
-        private static bool IsBuiltInType(
-            ExpressionSyntax initializerExpression,
-            SemanticModel semanticModel,
-            CancellationToken cancellationToken) =>
-                IsBuiltInType(semanticModel.GetTypeInfo(initializerExpression, cancellationToken).Type);
-
         public static bool IsBuiltInType(ITypeSymbol type)
             => type?.IsSpecialType() == true;
 
@@ -57,13 +25,13 @@ public static bool IsBuiltInType(ITypeSymbol type)
         }
 
         private static bool IsImplicitStylePreferred(
-            TypeStylePreference stylePreferences, bool isBuiltInTypeContext, bool isTypeApparentContext)
+            UseVarPreference stylePreferences, bool isBuiltInTypeContext, bool isTypeApparentContext)
         {
             return isBuiltInTypeContext
-                    ? stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeForIntrinsicTypes)
+                    ? stylePreferences.HasFlag(UseVarPreference.ForBuiltInTypes)
                     : isTypeApparentContext
-                        ? stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWhereApparent)
-                        : stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWherePossible);
+                        ? stylePreferences.HasFlag(UseVarPreference.WhenTypeIsApparent)
+                        : stylePreferences.HasFlag(UseVarPreference.Elsewhere);
         }
 
         /// <summary>
@@ -75,19 +43,34 @@ public static bool IsBuiltInType(ITypeSymbol type)
         /// Things (like analyzers) that do have a local declaration already, should pass this in.
         /// </remarks>
         public static bool IsTypeApparentInAssignmentExpression(
-            TypeStylePreference stylePreferences,
+            UseVarPreference stylePreferences,
             ExpressionSyntax initializerExpression,
             SemanticModel semanticModel,
-            CancellationToken cancellationToken,
-            ITypeSymbol typeInDeclaration = null)
+            ITypeSymbol typeInDeclaration,
+            CancellationToken cancellationToken)
         {
             // tuple literals
             if (initializerExpression.IsKind(SyntaxKind.TupleExpression))
             {
                 var tuple = (TupleExpressionSyntax)initializerExpression;
-                foreach (var argument in tuple.Arguments)
+                if (typeInDeclaration == null || !typeInDeclaration.IsTupleType)
+                {
+                    return false;
+                }
+
+                var tupleType = (INamedTypeSymbol)typeInDeclaration;
+                if (tupleType.TupleElements.Length != tuple.Arguments.Count)
+                {
+                    return false;
+                }
+
+                for (int i = 0, n = tuple.Arguments.Count; i < n; i++)
                 {
-                    if (!IsTypeApparentInAssignmentExpression(stylePreferences, argument.Expression, semanticModel, cancellationToken, typeInDeclaration))
+                    var argument = tuple.Arguments[i];
+                    var tupleElementType = tupleType.TupleElements[i].Type;
+
+                    if (!IsTypeApparentInAssignmentExpression(
+                            stylePreferences, argument.Expression, semanticModel, tupleElementType, cancellationToken))
                     {
                         return false;
                     }
@@ -105,7 +88,7 @@ public static bool IsBuiltInType(ITypeSymbol type)
             // literals, use var if options allow usage here.
             if (initializerExpression.IsAnyLiteralExpression())
             {
-                return stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeForIntrinsicTypes);
+                return stylePreferences.HasFlag(UseVarPreference.ForBuiltInTypes);
             }
 
             // constructor invocations cases:
@@ -255,27 +238,27 @@ private static ExpressionSyntax GetRightmostInvocationExpression(ExpressionSynta
             return node;
         }
 
-        private static TypeStylePreference GetCurrentTypeStylePreferences(OptionSet optionSet)
+        private static UseVarPreference GetCurrentTypeStylePreferences(OptionSet optionSet)
         {
-            var stylePreferences = TypeStylePreference.None;
+            var stylePreferences = UseVarPreference.None;
 
-            var styleForIntrinsicTypes = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes);
-            var styleForApparent = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent);
-            var styleForElsewhere = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible);
+            var styleForIntrinsicTypes = optionSet.GetOption(CSharpCodeStyleOptions.VarForBuiltInTypes);
+            var styleForApparent = optionSet.GetOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent);
+            var styleForElsewhere = optionSet.GetOption(CSharpCodeStyleOptions.VarElsewhere);
 
             if (styleForIntrinsicTypes.Value)
             {
-                stylePreferences |= TypeStylePreference.ImplicitTypeForIntrinsicTypes;
+                stylePreferences |= UseVarPreference.ForBuiltInTypes;
             }
 
             if (styleForApparent.Value)
             {
-                stylePreferences |= TypeStylePreference.ImplicitTypeWhereApparent;
+                stylePreferences |= UseVarPreference.WhenTypeIsApparent;
             }
 
             if (styleForElsewhere.Value)
             {
-                stylePreferences |= TypeStylePreference.ImplicitTypeWherePossible;
+                stylePreferences |= UseVarPreference.Elsewhere;
             }
 
             return stylePreferences;

src/Workspaces/CSharp/Portable/Utilities/CSharpTypeStyleHelper.State.cs

@@ -16,9 +16,9 @@ internal partial class CSharpTypeStyleHelper
     {
         protected class State
         {
-            private readonly Dictionary<TypeStylePreference, ReportDiagnostic> _styleToSeverityMap;
+            private readonly Dictionary<UseVarPreference, ReportDiagnostic> _styleToSeverityMap;
 
-            public TypeStylePreference TypeStylePreference { get; private set; }
+            public UseVarPreference TypeStylePreference { get; private set; }
             public bool IsInIntrinsicTypeContext { get; private set; }
             public bool IsTypeApparentInContext { get; private set; }
             public bool IsInVariableDeclarationContext { get; }
@@ -26,7 +26,7 @@ protected class State
             private State(bool isVariableDeclarationContext)
             {
                 this.IsInVariableDeclarationContext = isVariableDeclarationContext;
-                _styleToSeverityMap = new Dictionary<TypeStylePreference, ReportDiagnostic>();
+                _styleToSeverityMap = new Dictionary<UseVarPreference, ReportDiagnostic>();
             }
 
             public static State Generate(
@@ -43,15 +43,15 @@ public ReportDiagnostic GetDiagnosticSeverityPreference()
             {
                 if (IsInIntrinsicTypeContext)
                 {
-                    return _styleToSeverityMap[TypeStylePreference.ImplicitTypeForIntrinsicTypes];
+                    return _styleToSeverityMap[UseVarPreference.ForBuiltInTypes];
                 }
                 else if (IsTypeApparentInContext)
                 {
-                    return _styleToSeverityMap[TypeStylePreference.ImplicitTypeWhereApparent];
+                    return _styleToSeverityMap[UseVarPreference.WhenTypeIsApparent];
                 }
                 else
                 {
-                    return _styleToSeverityMap[TypeStylePreference.ImplicitTypeWherePossible];
+                    return _styleToSeverityMap[UseVarPreference.Elsewhere];
                 }
             }
 
@@ -72,7 +72,7 @@ private void Initialize(SyntaxNode declaration, SemanticModel semanticModel, Opt
             /// Returns true if type information could be gleaned by simply looking at the given statement.
             /// This typically means that the type name occurs in right hand side of an assignment.
             /// </summary>
-            private bool IsTypeApparentInDeclaration(VariableDeclarationSyntax variableDeclaration, SemanticModel semanticModel, TypeStylePreference stylePreferences, CancellationToken cancellationToken)
+            private bool IsTypeApparentInDeclaration(VariableDeclarationSyntax variableDeclaration, SemanticModel semanticModel, UseVarPreference stylePreferences, CancellationToken cancellationToken)
             {
                 if (variableDeclaration.Variables.Count != 1)
                 {
@@ -87,7 +87,7 @@ private bool IsTypeApparentInDeclaration(VariableDeclarationSyntax variableDecla
 
                 var initializerExpression = CSharpUseImplicitTypeHelper.GetInitializerExpression(initializer.Value);
                 var declaredTypeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type.StripRefIfNeeded(), cancellationToken).Type;
-                return TypeStyleHelper.IsTypeApparentInAssignmentExpression(stylePreferences, initializerExpression, semanticModel, cancellationToken, declaredTypeSymbol);
+                return TypeStyleHelper.IsTypeApparentInAssignmentExpression(stylePreferences, initializerExpression, semanticModel, declaredTypeSymbol, cancellationToken);
             }
 
             /// <summary>
@@ -162,31 +162,31 @@ private TypeSyntax GetTypeSyntaxFromDeclaration(SyntaxNode declarationStatement)
                 return null;
             }
 
-            private TypeStylePreference GetCurrentTypeStylePreferences(OptionSet optionSet)
+            private UseVarPreference GetCurrentTypeStylePreferences(OptionSet optionSet)
             {
-                var stylePreferences = TypeStylePreference.None;
+                var stylePreferences = UseVarPreference.None;
 
-                var styleForIntrinsicTypes = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes);
-                var styleForApparent = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent);
-                var styleForElsewhere = optionSet.GetOption(CSharpCodeStyleOptions.UseImplicitTypeWherePossible);
+                var styleForIntrinsicTypes = optionSet.GetOption(CSharpCodeStyleOptions.VarForBuiltInTypes);
+                var styleForApparent = optionSet.GetOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent);
+                var styleForElsewhere = optionSet.GetOption(CSharpCodeStyleOptions.VarElsewhere);
 
-                _styleToSeverityMap.Add(TypeStylePreference.ImplicitTypeForIntrinsicTypes, styleForIntrinsicTypes.Notification.Severity);
-                _styleToSeverityMap.Add(TypeStylePreference.ImplicitTypeWhereApparent, styleForApparent.Notification.Severity);
-                _styleToSeverityMap.Add(TypeStylePreference.ImplicitTypeWherePossible, styleForElsewhere.Notification.Severity);
+                _styleToSeverityMap.Add(UseVarPreference.ForBuiltInTypes, styleForIntrinsicTypes.Notification.Severity);
+                _styleToSeverityMap.Add(UseVarPreference.WhenTypeIsApparent, styleForApparent.Notification.Severity);
+                _styleToSeverityMap.Add(UseVarPreference.Elsewhere, styleForElsewhere.Notification.Severity);
 
                 if (styleForIntrinsicTypes.Value)
                 {
-                    stylePreferences |= TypeStylePreference.ImplicitTypeForIntrinsicTypes;
+                    stylePreferences |= UseVarPreference.ForBuiltInTypes;
                 }
 
                 if (styleForApparent.Value)
                 {
-                    stylePreferences |= TypeStylePreference.ImplicitTypeWhereApparent;
+                    stylePreferences |= UseVarPreference.WhenTypeIsApparent;
                 }
 
                 if (styleForElsewhere.Value)
                 {
-                    stylePreferences |= TypeStylePreference.ImplicitTypeWherePossible;
+                    stylePreferences |= UseVarPreference.Elsewhere;
                 }
 
                 return stylePreferences;

src/Workspaces/CSharp/Portable/Utilities/CSharpUseExplicitTypeHelper.cs

@@ -26,15 +26,15 @@ private CSharpUseExplicitTypeHelper()
 
             if (state.IsInIntrinsicTypeContext)
             {
-                return !stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeForIntrinsicTypes);
+                return !stylePreferences.HasFlag(UseVarPreference.ForBuiltInTypes);
             }
             else if (state.IsTypeApparentInContext)
             {
-                return !stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWhereApparent);
+                return !stylePreferences.HasFlag(UseVarPreference.WhenTypeIsApparent);
             }
             else
             {
-                return !stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWherePossible);
+                return !stylePreferences.HasFlag(UseVarPreference.Elsewhere);
             }
         }
 

src/Workspaces/CSharp/Portable/Utilities/CSharpUseImplicitTypeHelper.cs

@@ -79,15 +79,15 @@ protected override bool ShouldAnalyzeForEachStatement(ForEachStatementSyntax for
 
             if (state.IsInIntrinsicTypeContext)
             {
-                return stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeForIntrinsicTypes);
+                return stylePreferences.HasFlag(UseVarPreference.ForBuiltInTypes);
             }
             else if (state.IsTypeApparentInContext)
             {
-                return stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWhereApparent);
+                return stylePreferences.HasFlag(UseVarPreference.WhenTypeIsApparent);
             }
             else
             {
-                return stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeWherePossible);
+                return stylePreferences.HasFlag(UseVarPreference.Elsewhere);
             }
         }
 

src/Workspaces/CoreTest/Execution/SnapshotSerializationTests.cs

@@ -342,7 +342,7 @@ public async Task OptionSet_Serialization_CustomValue()
 
             workspace.Options = workspace.Options.WithChangedOption(CodeStyleOptions.QualifyFieldAccess, LanguageNames.CSharp, new CodeStyleOption<bool>(false, NotificationOption.Error))
                                                  .WithChangedOption(CodeStyleOptions.QualifyMethodAccess, LanguageNames.VisualBasic, new CodeStyleOption<bool>(true, NotificationOption.Warning))
-                                                 .WithChangedOption(CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion))
+                                                 .WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, new CodeStyleOption<bool>(false, NotificationOption.Suggestion))
                                                  .WithChangedOption(CodeStyleOptions.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, LanguageNames.VisualBasic, new CodeStyleOption<bool>(true, NotificationOption.Silent));
 
             await VerifyOptionSetsAsync(workspace, LanguageNames.CSharp).ConfigureAwait(false);