Localize all strings

localize all the string resources for use var or use explicit typing
analyzers and fixers.

src/Features/CSharp/Portable/CSharpFeaturesResources.Designer.cs

@@ -907,6 +907,42 @@ internal class CSharpFeaturesResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use explicit typing instead of &apos;var&apos;.
+        /// </summary>
+        internal static string UseExplicitTyping {
+            get {
+                return ResourceManager.GetString("UseExplicitTyping", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Use explicit typing.
+        /// </summary>
+        internal static string UseExplicitTypingDiagnosticTitle {
+            get {
+                return ResourceManager.GetString("UseExplicitTypingDiagnosticTitle", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to use &apos;var&apos; instead of typename.
+        /// </summary>
+        internal static string UseImplicitTyping {
+            get {
+                return ResourceManager.GetString("UseImplicitTyping", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Use implicit typing.
+        /// </summary>
+        internal static string UseImplicitTypingDiagnosticTitle {
+            get {
+                return ResourceManager.GetString("UseImplicitTypingDiagnosticTitle", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to using directive.
         /// </summary>

src/Features/CSharp/Portable/CSharpFeaturesResources.resx

@@ -437,4 +437,16 @@
   <data name="DelegateInvocationCanBeSimplified" xml:space="preserve">
     <value>Delegate invocation can be simplified.</value>
   </data>
+  <data name="UseExplicitTyping" xml:space="preserve">
+    <value>Use explicit typing instead of 'var'</value>
+  </data>
+  <data name="UseExplicitTypingDiagnosticTitle" xml:space="preserve">
+    <value>Use explicit typing</value>
+  </data>
+  <data name="UseImplicitTyping" xml:space="preserve">
+    <value>use 'var' instead of typename</value>
+  </data>
+  <data name="UseImplicitTypingDiagnosticTitle" xml:space="preserve">
+    <value>Use implicit typing</value>
+  </data>
 </root>
\ No newline at end of file

src/Features/CSharp/Portable/CodeFixes/UseImplicitTyping/UseExplicitTypingCodeFixProvider.cs

@@ -46,7 +46,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
 
             var codeAction = new MyCodeAction(
-                "Use typename instead of var", // TODO: use localizable strings.
+                CSharpFeaturesResources.UseExplicitTyping,
                 c => HandleDeclaration(document, root, node, context.CancellationToken));
 
             context.RegisterCodeFix(codeAction, context.Diagnostics.First());

src/Features/CSharp/Portable/CodeFixes/UseImplicitTyping/UseImplicitTypingCodeFixProvider.cs

@@ -44,7 +44,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
 
             var codeAction = new MyCodeAction(
-                                "Use var", // TODO: use localizable strings.
+                                CSharpFeaturesResources.UseImplicitTyping,
                                 c => ReplaceTypeWithVar(context, document, root, node));
 
             context.RegisterCodeFix(codeAction, context.Diagnostics.First());

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

@@ -13,7 +13,7 @@ internal static class CSharpCodeStyleOptions
     {
         internal const string FeatureName = "CSharpCodeStyle";
 
-        // TODO (BalajiK): repurpose this instead of adding a new one below?
+        // TODO: get sign off on public api changes.
         public static readonly Option<bool> UseVarWhenDeclaringLocals = new Option<bool>(FeatureName, "UseVarWhenDeclaringLocals", defaultValue: true);
 
         public static readonly Option<bool> UseVarForIntrinsicTypes = new Option<bool>(FeatureName, "UseImplicitTypingForIntrinsics", defaultValue: false);

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

@@ -43,9 +43,6 @@ public CSharpTypingStyleDiagnosticAnalyzerBase(DiagnosticDescriptor descriptor)
 
         public override void Initialize(AnalysisContext context)
         {
-            // TODO: check for generatedcode and bail.
-            // context.ConfigureGeneratedCodeAnalysis() See https://github.com/dotnet/roslyn/pull/7526
-
             context.RegisterSyntaxNodeAction(HandleVariableDeclaration, SyntaxKind.VariableDeclaration, SyntaxKind.ForEachStatement);
         }
 

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

@@ -14,18 +14,19 @@ namespace Microsoft.CodeAnalysis.CSharp.Diagnostics.TypingStyles
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal sealed class CSharpUseExplicitTypingDiagnosticAnalyzer : CSharpTypingStyleDiagnosticAnalyzerBase
     {
-        // TODO: 
-        // 1. localize title and message
-        // 2. tweak severity and custom tags 
-        //      a. need to have various levels of diagnostics to report based on option settings.
+        private static readonly LocalizableString s_Title =
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.UseExplicitTypingDiagnosticTitle), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources));
+
+        private static readonly LocalizableString s_Message =
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.UseExplicitTyping), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources));
+
         private static readonly DiagnosticDescriptor s_descriptorUseImplicitTyping = new DiagnosticDescriptor(
             id: IDEDiagnosticIds.UseExplicitTypingDiagnosticId,
-            title: "Use explicit typing",
-            messageFormat: "Use type name instead of var",
+            title: s_Title,
+            messageFormat: s_Message,
             category: DiagnosticCategory.Style,
             defaultSeverity: DiagnosticSeverity.Info,
-            isEnabledByDefault: true,
-            customTags: DiagnosticCustomTags.Unnecessary);
+            isEnabledByDefault: true);
 
         public CSharpUseExplicitTypingDiagnosticAnalyzer() : base(s_descriptorUseImplicitTyping)
         {

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

@@ -3,7 +3,6 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -16,18 +15,20 @@ namespace Microsoft.CodeAnalysis.CSharp.Diagnostics.TypingStyles
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal sealed class CSharpUseImplicitTypingDiagnosticAnalyzer : CSharpTypingStyleDiagnosticAnalyzerBase
     {
-        // TODO: 
-        // 1. localize title and message
-        // 2. tweak severity and custom tags 
-        //      a. need to have various levels of diagnostics to report based on option settings.
+
+        private static readonly LocalizableString s_Title =
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.UseImplicitTypingDiagnosticTitle), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources));
+
+        private static readonly LocalizableString s_Message =
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.UseImplicitTyping), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources));
+
         private static readonly DiagnosticDescriptor s_descriptorUseImplicitTyping = new DiagnosticDescriptor(
             id: IDEDiagnosticIds.UseImplicitTypingDiagnosticId,
-            title: "Use implicit typing",
-            messageFormat: "Use var instead of explicit type name",
+            title: s_Title,
+            messageFormat: s_Message,
             category: DiagnosticCategory.Style,
             defaultSeverity: DiagnosticSeverity.Info,
-            isEnabledByDefault: true,
-            customTags: DiagnosticCustomTags.Unnecessary);
+            isEnabledByDefault: true);
 
         public CSharpUseImplicitTypingDiagnosticAnalyzer() : base(s_descriptorUseImplicitTyping)
         {

src/VisualStudio/CSharp/Impl/CSharpVSResources.Designer.cs

@@ -699,6 +699,15 @@ internal class CSharpVSResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Type Inference preferences:.
+        /// </summary>
+        internal static string SetTypeInferencePreferences {
+            get {
+                return ResourceManager.GetString("SetTypeInferencePreferences", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Insert space after cast.
         /// </summary>
@@ -915,6 +924,15 @@ internal class CSharpVSResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use &apos;var&apos; for intrinsic types.
+        /// </summary>
+        internal static string UseVarForIntrinsicTypes {
+            get {
+                return ResourceManager.GetString("UseVarForIntrinsicTypes", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Use &apos;var&apos; when generating locals.
         /// </summary>
@@ -924,6 +942,24 @@ internal class CSharpVSResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use &apos;var&apos; in all other places as well.
+        /// </summary>
+        internal static string UseVarWhenPossible {
+            get {
+                return ResourceManager.GetString("UseVarWhenPossible", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Use &apos;var&apos; when type information is apparent.
+        /// </summary>
+        internal static string UseVarWhenTypeIsApparent {
+            get {
+                return ResourceManager.GetString("UseVarWhenTypeIsApparent", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Leave statements and member declarations on the same line.
         /// </summary>

src/VisualStudio/CSharp/Impl/CSharpVSResources.resx

@@ -411,4 +411,16 @@
   <data name="NewLinesForBracesProperty" xml:space="preserve">
     <value>Place open brace on new line for properties, indexers, and events</value>
   </data>
+  <data name="SetTypeInferencePreferences" xml:space="preserve">
+    <value>Type Inference preferences:</value>
+  </data>
+  <data name="UseVarForIntrinsicTypes" xml:space="preserve">
+    <value>Use 'var' for intrinsic types</value>
+  </data>
+  <data name="UseVarWhenPossible" xml:space="preserve">
+    <value>Use 'var' in all other places as well</value>
+  </data>
+  <data name="UseVarWhenTypeIsApparent" xml:space="preserve">
+    <value>Use 'var' when type information is apparent</value>
+  </data>
 </root>
\ No newline at end of file

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

@@ -179,12 +179,11 @@ internal StyleViewModel(OptionSet optionSet, IServiceProvider serviceProvider) :
             Items.Add(new CheckBoxOptionViewModel(SimplificationOptions.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, CSharpVSResources.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, s_intrinsicPreviewMemberAccessTrue, s_intrinsicPreviewMemberAccessFalse, this, optionSet));
             Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarWhenDeclaringLocals, CSharpVSResources.UseVarWhenGeneratingLocals, s_varPreviewTrue, s_varPreviewFalse, this, optionSet));
 
-            // TODO (BalajiK): Localize all strings from here.
-            Items.Add(new HeaderItemViewModel() { Header = "Type Inference preferences:" });
+            Items.Add(new HeaderItemViewModel() { Header = CSharpVSResources.SetTypeInferencePreferences });
 
-            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarForIntrinsicTypes, "use var for intrinsic types", s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionSet));
-            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarWhenTypeIsApparent, "use var where typing is apparent", s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionSet));
-            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarWherePossible, "use var where possible", s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionSet));
+            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarForIntrinsicTypes, CSharpVSResources.UseVarForIntrinsicTypes, s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionSet));
+            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarWhenTypeIsApparent, CSharpVSResources.UseVarWhenTypeIsApparent, s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionSet));
+            Items.Add(new CheckBoxOptionViewModel(CSharpCodeStyleOptions.UseVarWherePossible, CSharpVSResources.UseVarWhenPossible, s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionSet));
         }
     }
 }