WIP: Move to Resx MVP #79297

Fanominals · 2025-07-08T21:35:19Z

Add initial support for string extraction and .resx integration

Detects hardcoded strings in source code.
Auto-generates resource names (with potential for AI-assisted naming).
Inserts new entries into a single .resx file.
Replaces original strings in code with references to the new resource entries.

This lays the foundation for improved localization and maintainability. Currently supports one .resx file; future updates may expand multi-file support and smarter naming strategies.

- Detects hardcoded strings in source code. - Auto-generates resource names (with potential for AI-assisted naming). - Inserts new entries into a single .resx file. - Replaces original strings in code with references to the new resource entries. This lays the foundation for improved localization and maintainability. Currently supports one .resx file; future updates may expand multi-file support and smarter naming strategies.

dotnet-policy-service · 2025-07-08T21:35:57Z

@Fanominals please read the following Contributor License Agreement(CLA). If you agree with the CLA, please reply with the following information.

@dotnet-policy-service agree [company="{your company}"]

Options:

(default - no company specified) I have sole ownership of intellectual property rights to my Submissions and I am not making Submissions in the course of work for my employer.
@dotnet-policy-service agree
(when company given) I am making Submissions in the course of work for my employer (or my employer has intellectual property rights in my Submissions by contract or applicable law). I have permission from my employer to make Submissions and enter into this Agreement on behalf of my employer. By signing below, the defined term “You” includes me and my employer.
@dotnet-policy-service agree company="Microsoft"

Contributor License Agreement

Contribution License Agreement

This Contribution License Agreement ( “Agreement” ) is agreed to by the party signing below ( “You” ),
and conveys certain license rights to the .NET Foundation ( “.NET Foundation” ) for Your contributions to
.NET Foundation open source projects. This Agreement is effective as of the latest signature date below.

1. Definitions.

“Code” means the computer software code, whether in human-readable or machine-executable form,
that is delivered by You to .NET Foundation under this Agreement.

“Project” means any of the projects owned or managed by .NET Foundation and offered under a license
approved by the Open Source Initiative (www.opensource.org).

“Submit” is the act of uploading, submitting, transmitting, or distributing code or other content to any
Project, including but not limited to communication on electronic mailing lists, source code control
systems, and issue tracking systems that are managed by, or on behalf of, the Project for the purpose of
discussing and improving that Project, but excluding communication that is conspicuously marked or
otherwise designated in writing by You as “Not a Submission.”

“Submission” means the Code and any other copyrightable material Submitted by You, including any
associated comments and documentation.

2. Your Submission. You must agree to the terms of this Agreement before making a Submission to any
Project. This Agreement covers any and all Submissions that You, now or in the future (except as
described in Section 4 below), Submit to any Project.

3. Originality of Work. You represent that each of Your Submissions is entirely Your
original work. Should You wish to Submit materials that are not Your original work,
You may Submit them separately to the Project if You (a) retain all copyright and
license information that was in the materials as you received them, (b) in the
description accompanying your Submission, include the phrase "Submission
containing materials of a third party:" followed by the names of the third party and any
licenses or other restrictions of which You are aware, and (c) follow any other
instructions in the Project's written guidelines concerning Submissions.

4. Your Employer. References to “employer” in this Agreement include Your employer or anyone else
for whom You are acting in making Your Submission, e.g. as a contractor, vendor, or agent. If Your
Submission is made in the course of Your work for an employer or Your employer has intellectual
property rights in Your Submission by contract or applicable law, You must secure permission from Your
employer to make the Submission before signing this Agreement. In that case, the term “You” in this
Agreement will refer to You and the employer collectively. If You change employers in the future and
desire to Submit additional Submissions for the new employer, then You agree to sign a new Agreement
and secure permission from the new employer before Submitting those Submissions.

5. Licenses.

a. Copyright License. You grant .NET Foundation, and those who receive the Submission directly
or indirectly from .NET Foundation, a perpetual, worldwide, non-exclusive, royalty-free, irrevocable
license in the Submission to reproduce, prepare derivative works of, publicly display, publicly perform,
and distribute the Submission and such derivative works, and to sublicense any or all of the foregoing
rights to third parties.

b. Patent License. You grant .NET Foundation, and those who receive the Submission directly or
indirectly from .NET Foundation, a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license
under Your patent claims that are necessarily infringed by the Submission or the combination of the
Submission with the Project to which it was Submitted to make, have made, use, offer to sell, sell and
import or otherwise dispose of the Submission alone or with the Project.

c. Other Rights Reserved. Each party reserves all rights not expressly granted in this Agreement.
No additional licenses or rights whatsoever (including, without limitation, any implied licenses) are
granted by implication, exhaustion, estoppel or otherwise.

6. Representations and Warranties. You represent that You are legally entitled to grant the above
licenses. You represent that each of Your Submissions is entirely Your original work (except as You may
have disclosed under Section 3 ). You represent that You have secured permission from Your employer to
make the Submission in cases where Your Submission is made in the course of Your work for Your
employer or Your employer has intellectual property rights in Your Submission by contract or applicable
law. If You are signing this Agreement on behalf of Your employer, You represent and warrant that You
have the necessary authority to bind the listed employer to the obligations contained in this Agreement.
You are not expected to provide support for Your Submission, unless You choose to do so. UNLESS
REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING, AND EXCEPT FOR THE WARRANTIES
EXPRESSLY STATED IN SECTIONS 3, 4, AND 6 , THE SUBMISSION PROVIDED UNDER THIS AGREEMENT IS
PROVIDED WITHOUT WARRANTY OF ANY KIND, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY OF
NONINFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.

7. Notice to .NET Foundation. You agree to notify .NET Foundation in writing of any facts or
circumstances of which You later become aware that would make Your representations in this
Agreement inaccurate in any respect.

8. Information about Submissions. You agree that contributions to Projects and information about
contributions may be maintained indefinitely and disclosed publicly, including Your name and other
information that You submit with Your Submission.

9. Governing Law/Jurisdiction. This Agreement is governed by the laws of the State of Washington, and
the parties consent to exclusive jurisdiction and venue in the federal courts sitting in King County,
Washington, unless no federal subject matter jurisdiction exists, in which case the parties consent to
exclusive jurisdiction and venue in the Superior Court of King County, Washington. The parties waive all
defenses of lack of personal jurisdiction and forum non-conveniens.

10. Entire Agreement/Assignment. This Agreement is the entire agreement between the parties, and
supersedes any and all prior agreements, understandings or communications, written or oral, between
the parties relating to the subject matter hereof. This Agreement may be assigned by .NET Foundation.

.NET Foundation dedicates this Contribution License Agreement to the public domain according to the Creative Commons CC0 1.

tmat · 2025-07-08T23:39:51Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+
+        private static TextDocument? FindBestResxFile(Project project, string? documentPath)
+        {
+            var allResx = project.AdditionalDocuments


Are resx files always included in additional files? I think they are only when ResxSourceGenerator package is used.

Hey, so in my experience ResX Files are not included in additional files and need to be manually added. When I was researching this, from what I read it was best practice to get the Resx files from additional documents for codefixes and analyzers but there could be something I am missing. I am reaching out to you on teams and maybe we can figure out a better implementation for this?

jaredpar · 2025-07-10T04:02:48Z

@JoeRobich, @dibarbet please take a look

jaredpar · 2025-07-10T04:07:33Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(MoveToResx.DiagnosticId);


Suggested change

public override ImmutableArray<string> FixableDiagnosticIds

=> ImmutableArray.Create(MoveToResx.DiagnosticId);

public override ImmutableArray<string> FixableDiagnosticIds

=> [MoveToResx.DiagnosticId];

Prefer collection expressions

jaredpar · 2025-07-10T04:09:47Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var diagnostic = context.Diagnostics[0];


Is it possible to have more than one diagnostic here?

@jaredpar no. This was based on an early iteration of code fixes that thought that might occur (for fix all). but that's not how fix all actually ended up working. but thsi was never revised. So this is fine to do.

jaredpar · 2025-07-10T04:10:59Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            var diagnostic = context.Diagnostics[0];
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var node = root?.FindNode(diagnostic.Location.SourceSpan) as LiteralExpressionSyntax;
+            if (node == null)


Suggested change

if (node == null)

if (node is null)

jaredpar · 2025-07-10T04:11:35Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        //private static IEnumerable<TextDocument> GetResxAdditionalFiles(Project project)
+        //{
+        //    foreach (var file in project.AdditionalDocuments)
+        //    {
+        //        if (file.FilePath != null &&
+        //            string.Equals(".resx", Path.GetExtension(file.FilePath), StringComparison.OrdinalIgnoreCase))
+        //        {
+        //            yield return file;
+        //        }
+        //    }
+        //}


Remove commented out code before merging.

JoeRobich · 2025-07-11T16:39:46Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxService.cs

+namespace Microsoft.CodeAnalysis.CSharp.MoveToResx;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal class MoveToResx : DiagnosticAnalyzer


Also, update filename to match.

Suggested change

internal class MoveToResx : DiagnosticAnalyzer

internal class CSharpMoveToResxDiagnosticAnalyzer : DiagnosticAnalyzer

also, seal the type.

JoeRobich · 2025-07-11T16:44:50Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxService.cs

+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal class MoveToResx : DiagnosticAnalyzer
+{
+    public const string DiagnosticId = "MoveToResx";


Add a new diagnostic id to IDEDiagnosticIds.cs instead of defining one here. Maybe IDE0360 makes sense.

JoeRobich · 2025-07-11T16:46:18Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxService.cs

+
+    private static void AnalyzeStringLiteral(SyntaxNodeAnalysisContext context)
+    {
+        var stringLiteral = (LiteralExpressionSyntax)context.Node;


Since we are not creating resource files yet, check whether a .resx file is reachable before reporting diagnostics. Meaning FindBestResxFile may need to be moved to a utilities class that your analyzer and codefix can share.

JoeRobich · 2025-07-11T16:49:42Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            // 2. Parse the SourceText with XDocument
+            var xdoc = XDocument.Parse(resxSourceText.ToString());
+
+            // 3. Add or update the resource entry


We should check to see if the string (not just the name) already exists in the resource file. If so we can grab the name and skip updating the .resx.

If we checked for this in the Analyzer, we may want to offer a separate diagnostic and fix for that. UseResxString or something similar.

Hey good idea! Making this change for the code fix. For the analyzer use case, how would the analyzer know which resx to check for the string. Would it check all available resx files?

CyrusNajmabadi · 2025-07-11T19:39:52Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+using System.Collections.Immutable;
+using System.IO;
+using System.Xml.Linq;
+using Microsoft.CodeAnalysis.CSharp;


nit: sort :)

CyrusNajmabadi · 2025-07-11T19:40:03Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+using System.Xml.Linq;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Microsoft.CodeAnalysis.CSharp.MoveToResx


nit: we use file scoped namespaces.

CyrusNajmabadi · 2025-07-11T19:40:26Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(CSharpMoveToResxCodeFixProvider)), Shared]
+    internal class CSharpMoveToResxCodeFixProvider : CodeFixProvider
+    {
+        [ImportingConstructor]


nit, this should have the obsolete attribute stating it should not be called directly (see other code fix providers).
Nit: use a primary constructor.

CyrusNajmabadi · 2025-07-11T19:40:32Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+namespace Microsoft.CodeAnalysis.CSharp.MoveToResx
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(CSharpMoveToResxCodeFixProvider)), Shared]
+    internal class CSharpMoveToResxCodeFixProvider : CodeFixProvider


nit: sealed

CyrusNajmabadi · 2025-07-11T19:41:05Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            => ImmutableArray.Create(MoveToResx.DiagnosticId);
+
+        public override FixAllProvider GetFixAllProvider()
+            => WellKnownFixAllProviders.BatchFixer;


not sure how effective this will be. we may want to write a custom fixer here. Do you have tests showing fix-all behavior?

Hey, great point. I am working on a custom fixer for this.

CyrusNajmabadi · 2025-07-11T19:42:36Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        {
+            var diagnostic = context.Diagnostics[0];
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var node = root?.FindNode(diagnostic.Location.SourceSpan) as LiteralExpressionSyntax;


Suggested change

var node = root?.FindNode(diagnostic.Location.SourceSpan) as LiteralExpressionSyntax;

var node = root?.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true) as LiteralExpressionSyntax;

This is needed for the scenario where you have Foo("SomeString") (and please test this). Your above code will get an ArgumentSyntax not its child LiteralExpressionSyntax here.

CyrusNajmabadi · 2025-07-11T19:43:05Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var diagnostic = context.Diagnostics[0];
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);


either do GetRequiredSyntaxRootAsync or use our existing helper, which is called something like context.TryGetRelevantNodeAsync<LiteralExpressionSyntax>()

CyrusNajmabadi · 2025-07-11T19:43:29Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            if (node == null)
+                return;
+
+            var resxFile = FindBestResxFile(context.Document.Project, context.Document.FilePath);


there are many forms of literals (like numbers, booleans, etc). you need to actually validate that this is a string literal/

CyrusNajmabadi · 2025-07-11T19:44:27Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+                var resxName = Path.GetFileName(resxFile.FilePath);
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: $"Move string to .resx resource ({resxName})",


ironic that the title itself is not localized :)

also, this indicates an interesting case we should support. We should find interpolated strings and offer to make them resources, converting it to then use string.Format at the call site.

CyrusNajmabadi · 2025-07-11T19:45:31Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            {
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: "No .resx file found. Please create a .resx file in your project or folder.",


we def would not do things this way normally. this will pop up a lightbulb (on every string) with something that does nothing. In this case, we should add the resx file to the project and populate it properly. This may require you to write a component at a higher layer, and not offer anything if you can't import that component here.

CyrusNajmabadi · 2025-07-11T19:46:23Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+                .ToList();
+
+            if (allResx.Count == 0 || documentPath == null)
+                return allResx.FirstOrDefault();


You should always have a document path. so this second clause won't ever hit.

fort he first clause, it's odd since you knwo the count is 0, so returning FirstOrDefualt is equivalent to jsut returning null.

CyrusNajmabadi · 2025-07-11T19:46:54Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            var resxSourceText = await resxFile.GetTextAsync(cancellationToken).ConfigureAwait(false);
+
+            // 2. Parse the SourceText with XDocument
+            var xdoc = XDocument.Parse(resxSourceText.ToString());


this can fail, throwing an exception. that woudl be bad.

CyrusNajmabadi · 2025-07-11T19:48:00Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            }
+            else
+            {
+                dataElement.Element("value")!.Value = value;


there's no guarantee that the resx file will be formed in the way you want. it's important to check for that and act gracefully there. these are also good test cases.

CyrusNajmabadi · 2025-07-11T19:49:03Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            // 7. Replace the string literal in the code with a resource reference, including namespace if available
+            var resourceClass = Path.GetFileNameWithoutExtension(resxFile.Name);
+            var ns = document.Project.DefaultNamespace;
+            string resourceAccessString = !string.IsNullOrEmpty(ns)


we don't abbr in the code. so use something like defaultNamespace, not 'ns'.

also, we should annotate this expression with a simplification annotation, so that the extraneous namespace/type name can be trimmed if possible int he destiation.

CyrusNajmabadi · 2025-07-11T19:49:30Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            return newSolution;
+        }
+
+        private static string ToDeterministicResourceKey(string value, int maxWords = 6)


why is this an optional argument?

CyrusNajmabadi · 2025-07-11T19:50:06Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+                words.Add(sb.ToString().ToLowerInvariant());
+
+            // Limit to maxWords
+            if (words.Count > maxWords)


this seems quite low. What i'd probably do instead is make the resource string as long as needed without going over a max length (like 60 chars) vs a max number of words (which could be any any length).

CyrusNajmabadi · 2025-07-11T19:50:21Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+                }
+            }
+            if (sb.Length > 0)
+                words.Add(sb.ToString().ToLowerInvariant());


why are we lowercasing the txt?

CyrusNajmabadi · 2025-07-11T19:50:31Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+
+            // Split the string into words using non-alphanumeric as delimiters
+            var words = new List<string>();
+            var sb = new StringBuilder();


builder, or stringBuilder

CyrusNajmabadi · 2025-07-11T19:50:38Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        private static string ToDeterministicResourceKey(string value, int maxWords = 6)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return "emptyString";


when does this happen?

CyrusNajmabadi · 2025-07-11T19:50:55Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+                words = words.Take(maxWords).ToList();
+
+            // Convert to lowerCamelCase
+            var keyBuilder = new StringBuilder();


Suggested change

var keyBuilder = new StringBuilder();

using var _ = PooledStringBuilder.GetInstance(out var keyBuilder);

CyrusNajmabadi · 2025-07-11T19:51:40Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxService.cs

+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();


we have existing DiagnosticAnalyzer subtypes that you can subclass yourself. They will take care of these sorts of common pieces of code.

CyrusNajmabadi · 2025-07-11T19:52:53Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxService.cs

+
+        // Report a diagnostic for every string literal
+        var diagnostic = Diagnostic.Create(s_moveToResxRule, stringLiteral.GetLocation(), stringLiteral.Token.ValueText);
+        context.ReportDiagnostic(diagnostic);


i think we need to do a bunch more up front checking. As an example, we really never want the code fixer part to ever fail (unless validating that it wouldn't fail woudl be prohibitively expensive).

So any locations where the fixer no-ops, we should check up here (for example, for things like the empty string).

CyrusNajmabadi · 2025-07-11T19:53:49Z

NOte: the analyzer and fixer should both be low-pri. This will show up on every string litearl, and will often not be what the user wants. So we should deprioritize it against existing analzyers/refactorings/fixers.

…-resx' into dev/gosingh/move-to-resx

Fanominals · 2025-07-19T01:47:17Z

@JoeRobich @CyrusNajmabadi @jaredpar

Ive added a fixall provider that works + addressed most of the things brought up so far.

Requesting a review on the new changes

JoeRobich · 2025-07-23T06:30:56Z

/azp run

azure-pipelines · 2025-07-23T06:31:14Z

Azure Pipelines successfully started running 3 pipeline(s).

JoeRobich · 2025-07-23T06:31:50Z

src/Features/CSharp/Portable/MoveToResx/CSharpRenameResxService.cs

@@ -0,0 +1,64 @@
+//// Licensed to the .NET Foundation under one or more agreements.


We do not want to commit commented out code. Remove until we are ready to move forward with this.

JoeRobich · 2025-07-23T06:33:29Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+            var resx = allResx.First();
+
+            return CodeAction.Create(
+                "Move all strings to .resx resource",


Move this string to the Resx. =)

JoeRobich · 2025-07-23T06:34:55Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                "Move string to .resx resource",


Move to Resx

JoeRobich · 2025-07-23T06:36:11Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+        {
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: "No .resx file found. Please create a .resx file in your project or folder.",


I still believe we should be checking for .resx files in the Analyzer.

JoeRobich · 2025-07-23T06:38:54Z

src/Features/CSharp/Portable/MoveToResx/CSharpMoveToResxCodeFixProvider.cs

+    Document document,
+    LiteralExpressionSyntax stringLiteral,
+    TextDocument resxFile,
+    CancellationToken cancellationToken)


nit: indent

JoeRobich

Seems like the code in the codefix and the fixall are fairly similar. Could we share it to reduce duplication?

JoeRobich and others added 4 commits June 20, 2025 09:56

Initial analyzer for identifying strings

dac7603

MVP for Move to Resource Analyzer and CodeFix

9e63642

Removed RenameResourceKey test (will add in a later commit)

886554d

Fanominals requested a review from a team as a code owner July 8, 2025 21:35

dotnet-policy-service bot added the VSCode label Jul 8, 2025

tmat reviewed Jul 8, 2025

View reviewed changes

jaredpar reviewed Jul 10, 2025

View reviewed changes

JoeRobich reviewed Jul 11, 2025

View reviewed changes

CyrusNajmabadi reviewed Jul 11, 2025

View reviewed changes

Fanominals added 3 commits July 11, 2025 14:21

Work in progress move to resx nested menu

2e381ac

removed feature that orders resx based on proximity to file directory

33c0a83

Worked on fixes from review

e7c9a7c

build-analysis bot mentioned this pull request Jul 15, 2025

The active test run was aborted. Reason: Test host process crashed dotnet/dnceng#451

Open

3 tasks

Fanominals added 4 commits July 18, 2025 11:22

fix all provider

405ff03

fix

13763ca

reworked fix all, and fixed most issues brought up on prev pr

fc5ca8b

Merge remote-tracking branch 'refs/remotes/origin/dev/gosingh/move-to…

97f48d1

…-resx' into dev/gosingh/move-to-resx

JoeRobich reviewed Jul 23, 2025

View reviewed changes

		public override ImmutableArray<string> FixableDiagnosticIds
		=> ImmutableArray.Create(MoveToResx.DiagnosticId);

	internal class MoveToResx : DiagnosticAnalyzer
	internal class CSharpMoveToResxDiagnosticAnalyzer : DiagnosticAnalyzer

	var node = root?.FindNode(diagnostic.Location.SourceSpan) as LiteralExpressionSyntax;
	var node = root?.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true) as LiteralExpressionSyntax;

	var keyBuilder = new StringBuilder();
	using var _ = PooledStringBuilder.GetInstance(out var keyBuilder);

		@@ -0,0 +1,64 @@
		//// Licensed to the .NET Foundation under one or more agreements.

WIP: Move to Resx MVP #79297

Are you sure you want to change the base?

WIP: Move to Resx MVP #79297

Uh oh!

Conversation

Fanominals commented Jul 8, 2025

Uh oh!

dotnet-policy-service bot commented Jul 8, 2025

Contribution License Agreement

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jaredpar commented Jul 10, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!