Add embedded classification support for locals passed into an annotated api at a later point (#75875)

CyrusNajmabadi · web-flow · commit 77d5fe7bfbae · 2024-11-14T15:21:24.000-05:00
diff --git a/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Json.cs b/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Json.cs
@@ -222,6 +222,35 @@ void Goo()
             Json.Array("]"));
     }
 
+    [Theory, CombinatorialData]
+    public async Task TestJsonOnApiWithStringSyntaxAttribute_Field_FromLocal(TestHost testHost)
+    {
+        await TestAsync(
+            """
+            using System.Diagnostics.CodeAnalysis;
+
+            class Program
+            {
+                [StringSyntax(StringSyntaxAttribute.Json)]
+                private string field;
+                void Goo()
+                {
+                    [|var v = @"[{ 'goo': 0}]";|]
+                    this.field = v;
+                }
+            }
+            """ + EmbeddedLanguagesTestConstants.StringSyntaxAttributeCodeCSharp,
+            testHost,
+            Keyword("var"),
+            Json.Array("["),
+            Json.Object("{"),
+            Json.PropertyName("'goo'"),
+            Json.Punctuation(":"),
+            Json.Number("0"),
+            Json.Object("}"),
+            Json.Array("]"));
+    }
+
     [Theory, CombinatorialData]
     [WorkItem("https://github.com/dotnet/roslyn/issues/74020")]
     public async Task TestJsonOnApiWithStringSyntaxAttribute_OtherLanguage_Field(TestHost testHost)
@@ -302,6 +331,37 @@ void Goo()
             Json.Array("]"));
     }
 
+    [Theory, CombinatorialData]
+    public async Task TestJsonOnApiWithStringSyntaxAttribute_Argument_FromLocal(TestHost testHost)
+    {
+        await TestAsync(
+            """
+            using System.Diagnostics.CodeAnalysis;
+
+            class Program
+            {
+                private void M([StringSyntax(StringSyntaxAttribute.Json)] string p)
+                {
+                }
+
+                void Goo()
+                {
+                    [|var v = @"[{ 'goo': 0}]";|]
+                    M(v);
+                }
+            }
+            """ + EmbeddedLanguagesTestConstants.StringSyntaxAttributeCodeCSharp,
+            testHost,
+            Keyword("var"),
+            Json.Array("["),
+            Json.Object("{"),
+            Json.PropertyName("'goo'"),
+            Json.Punctuation(":"),
+            Json.Number("0"),
+            Json.Object("}"),
+            Json.Array("]"));
+    }
+
     [Theory, CombinatorialData]
     [WorkItem("https://github.com/dotnet/roslyn/issues/69237")]
     public async Task TestJsonOnApiWithStringSyntaxAttribute_PropertyInitializer(TestHost testHost)
@@ -335,6 +395,40 @@ void Goo()
             Json.Array("]"));
     }
 
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/69237")]
+    public async Task TestJsonOnApiWithStringSyntaxAttribute_PropertyInitializer_FromLocal(TestHost testHost)
+    {
+        await TestAsync(
+            """"
+            using System.Diagnostics.CodeAnalysis;
+
+            public sealed record Foo
+            {
+                [StringSyntax(StringSyntaxAttribute.Json)]
+                public required string Bar { get; set; }
+            }
+
+            class Program
+            {
+                void Goo()
+                {
+                    [|var v = """[1, 2, 3]""";|]
+                    var f = new Foo { Bar = v };
+                }
+            }
+            """" + EmbeddedLanguagesTestConstants.StringSyntaxAttributeCodeCSharp,
+            testHost,
+            Keyword("var"),
+            Json.Array("["),
+            Json.Number("1"),
+            Json.Punctuation(","),
+            Json.Number("2"),
+            Json.Punctuation(","),
+            Json.Number("3"),
+            Json.Array("]"));
+    }
+
     [Theory, CombinatorialData]
     [WorkItem("https://github.com/dotnet/roslyn/issues/69237")]
     public async Task TestJsonOnApiWithStringSyntaxAttribute_WithExpression(TestHost testHost)
@@ -368,4 +462,75 @@ void Goo()
             Json.Number("3"),
             Json.Array("]"));
     }
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/69237")]
+    public async Task TestJsonOnApiWithStringSyntaxAttribute_WithExpression_FromLocal(TestHost testHost)
+    {
+        await TestAsync(
+            """"
+            using System.Diagnostics.CodeAnalysis;
+
+            public sealed record Foo
+            {
+                [StringSyntax(StringSyntaxAttribute.Json)]
+                public required string Bar { get; set; }
+            }
+
+            class Program
+            {
+                void Goo()
+                {
+                    var f = new Foo { Bar =  "" };
+                    [|var v = """[1, 2, 3]""";|]
+                    f = f with { Bar = v };
+                }
+            }
+            """" + EmbeddedLanguagesTestConstants.StringSyntaxAttributeCodeCSharp,
+            testHost,
+            Keyword("var"),
+            Json.Array("["),
+            Json.Number("1"),
+            Json.Punctuation(","),
+            Json.Number("2"),
+            Json.Punctuation(","),
+            Json.Number("3"),
+            Json.Array("]"));
+    }
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/69237")]
+    public async Task TestJsonOnApiWithStringSyntaxAttribute_WithExpression_FromLocal2(TestHost testHost)
+    {
+        await TestAsync(
+            """"
+            using System.Diagnostics.CodeAnalysis;
+
+            public sealed record Foo
+            {
+                [StringSyntax(StringSyntaxAttribute.Json)]
+                public required string Bar { get; set; }
+            }
+
+            class Program
+            {
+                void Goo()
+                {
+                    var f = new Foo { Bar =  "" };
+                    string v;
+                    [|v = """[1, 2, 3]""";|]
+                    f = f with { Bar = v };
+                }
+            }
+            """" + EmbeddedLanguagesTestConstants.StringSyntaxAttributeCodeCSharp,
+            testHost,
+            Local("v"),
+            Json.Array("["),
+            Json.Number("1"),
+            Json.Punctuation(","),
+            Json.Number("2"),
+            Json.Punctuation(","),
+            Json.Number("3"),
+            Json.Array("]"));
+    }
 }
diff --git a/src/Features/CSharp/Portable/EmbeddedLanguages/CSharpEmbeddedLanguagesProvider.cs b/src/Features/CSharp/Portable/EmbeddedLanguages/CSharpEmbeddedLanguagesProvider.cs
@@ -13,20 +13,16 @@
 namespace Microsoft.CodeAnalysis.CSharp.EmbeddedLanguages.LanguageServices;
 
 [ExportLanguageService(typeof(IEmbeddedLanguagesProvider), LanguageNames.CSharp, ServiceLayer.Default), Shared]
-internal class CSharpEmbeddedLanguagesProvider : AbstractEmbeddedLanguagesProvider
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class CSharpEmbeddedLanguagesProvider() : AbstractEmbeddedLanguagesProvider(Info)
 {
     public static readonly EmbeddedLanguageInfo Info = new(
+        CSharpBlockFacts.Instance,
         CSharpSyntaxFacts.Instance,
         CSharpSemanticFactsService.Instance,
         CSharpVirtualCharService.Instance);
 
-    [ImportingConstructor]
-    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-    public CSharpEmbeddedLanguagesProvider()
-        : base(Info)
-    {
-    }
-
     public override string EscapeText(string text, SyntaxToken token)
         => EmbeddedLanguageUtilities.EscapeText(text, token);
 }
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs b/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
@@ -198,21 +199,18 @@ private bool IsEmbeddedLanguageInterpolatedStringTextToken(
         return HasMatchingStringSyntaxAttribute(method.Parameters[0], out identifier);
     }
 
-    private bool IsEmbeddedLanguageStringLiteralToken(
+    /// <summary>
+    /// Checks for a string literal <em>directly</em> used in a location we can tell is controlled by a
+    /// <c>[StringSyntax]</c> attribute.
+    /// </summary>
+    private bool IsEmbeddedLanguageStringLiteralToken_Direct(
         SyntaxToken token,
         SemanticModel semanticModel,
         CancellationToken cancellationToken,
-        [NotNullWhen(true)] out string? identifier,
-        out IEnumerable<string>? options)
+        [NotNullWhen(true)] out string? identifier)
     {
         identifier = null;
-        options = null;
         var syntaxFacts = Info.SyntaxFacts;
-        if (!syntaxFacts.IsLiteralExpression(token.Parent))
-            return false;
-
-        if (HasLanguageComment(token, syntaxFacts, out identifier, out options))
-            return true;
 
         // If we're a string used in a collection initializer, treat this as a lang string if the collection itself
         // is properly annotated.  This is for APIs that do things like DateTime.ParseExact(..., string[] formats, ...);
@@ -276,6 +274,111 @@ private bool IsEmbeddedLanguageStringLiteralToken(
         return false;
     }
 
+    private bool IsEmbeddedLanguageStringLiteralToken(
+        SyntaxToken token,
+        SemanticModel semanticModel,
+        CancellationToken cancellationToken,
+        [NotNullWhen(true)] out string? identifier,
+        out IEnumerable<string>? options)
+    {
+        identifier = null;
+        options = null;
+        var syntaxFacts = Info.SyntaxFacts;
+        if (!syntaxFacts.IsLiteralExpression(token.Parent))
+            return false;
+
+        if (HasLanguageComment(token, syntaxFacts, out identifier, out options))
+            return true;
+
+        // Check for *direct* usage of this token that indicates it's an embedded language string.  Like passing it to
+        // an argument which has the StringSyntax attribute on it.
+        if (IsEmbeddedLanguageStringLiteralToken_Direct(
+                token, semanticModel, cancellationToken, out identifier))
+        {
+            return true;
+        }
+
+        // Now check for if the literal was assigned to a local that we then see is passed along to something that
+        // indicates an embedded language string at some later point.
+
+        var container = TryFindContainer(token);
+        if (container is null)
+            return false;
+
+        var statement = container.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsStatement);
+        if (syntaxFacts.IsSimpleAssignmentStatement(statement))
+        {
+            syntaxFacts.GetPartsOfAssignmentStatement(statement, out var left, out var right);
+            return container == right &&
+                IsLocalConsumedByApiWithStringSyntaxAttribute(
+                    semanticModel.GetSymbolInfo(left, cancellationToken).GetAnySymbol(), container, semanticModel, cancellationToken, out identifier);
+        }
+
+        if (syntaxFacts.IsEqualsValueClause(container.Parent) &&
+            syntaxFacts.IsVariableDeclarator(container.Parent.Parent))
+        {
+            var variableDeclarator = container.Parent.Parent;
+            var symbol =
+                semanticModel.GetDeclaredSymbol(variableDeclarator, cancellationToken) ??
+                semanticModel.GetDeclaredSymbol(syntaxFacts.GetIdentifierOfVariableDeclarator(variableDeclarator).GetRequiredParent(), cancellationToken);
+
+            return IsLocalConsumedByApiWithStringSyntaxAttribute(symbol, container, semanticModel, cancellationToken, out identifier);
+        }
+
+        return false;
+    }
+
+    private bool IsLocalConsumedByApiWithStringSyntaxAttribute(
+        ISymbol? symbol,
+        SyntaxNode tokenParent,
+        SemanticModel semanticModel,
+        CancellationToken cancellationToken,
+        [NotNullWhen(true)] out string? identifier)
+    {
+        identifier = null;
+        if (symbol is not ILocalSymbol localSymbol)
+            return false;
+
+        var blockFacts = this.Info.BlockFacts;
+        var syntaxFacts = this.Info.SyntaxFacts;
+
+        var block = tokenParent.AncestorsAndSelf().FirstOrDefault(blockFacts.IsExecutableBlock);
+        if (block is null)
+            return false;
+
+        var localName = localSymbol.Name;
+        if (localName == "")
+            return false;
+
+        // Now look at the next statements that follow for usages of this local variable.
+        foreach (var statement in blockFacts.GetExecutableBlockStatements(block))
+        {
+            foreach (var descendent in statement.DescendantNodesAndSelf())
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (!syntaxFacts.IsIdentifierName(descendent))
+                    continue;
+
+                var identifierToken = syntaxFacts.GetIdentifierOfIdentifierName(descendent);
+                if (identifierToken.ValueText != localName)
+                    continue;
+
+                var otherSymbol = semanticModel.GetSymbolInfo(descendent, cancellationToken).GetAnySymbol();
+
+                // Only do a direct check here.  We don't want to continually do indirect checks where a string literal
+                // is assigned to one local, assigned to another local, assigned to another local, and so on.
+                if (localSymbol.Equals(otherSymbol) &&
+                    IsEmbeddedLanguageStringLiteralToken_Direct(identifierToken, semanticModel, cancellationToken, out identifier))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private SyntaxNode? TryFindContainer(SyntaxToken token)
     {
         var syntaxFacts = Info.SyntaxFacts;
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageInfo.cs b/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageInfo.cs
@@ -11,17 +11,20 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages;
 
 internal readonly struct EmbeddedLanguageInfo
 {
+    public readonly IBlockFacts BlockFacts;
     public readonly ISyntaxFacts SyntaxFacts;
     public readonly ISemanticFactsService SemanticFacts;
     public readonly IVirtualCharService VirtualCharService;
 
     public readonly ISyntaxKinds SyntaxKinds => SyntaxFacts.SyntaxKinds;
 
     public EmbeddedLanguageInfo(
+        IBlockFacts blockFacts,
         ISyntaxFacts syntaxFacts,
         ISemanticFactsService semanticFacts,
         IVirtualCharService virtualCharService)
     {
+        BlockFacts = blockFacts;
         SyntaxFacts = syntaxFacts;
         SemanticFacts = semanticFacts;
         VirtualCharService = virtualCharService;
diff --git a/src/Features/VisualBasic/Portable/EmbeddedLanguages/VisualBasicEmbeddedLanguagesProvider.vb b/src/Features/VisualBasic/Portable/EmbeddedLanguages/VisualBasicEmbeddedLanguagesProvider.vb
@@ -11,10 +11,11 @@ Imports Microsoft.CodeAnalysis.VisualBasic.LanguageService
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.EmbeddedLanguages.LanguageServices
     <ExportLanguageService(GetType(IEmbeddedLanguagesProvider), LanguageNames.VisualBasic, ServiceLayer.Default), [Shared]>
-    Friend Class VisualBasicEmbeddedLanguagesProvider
+    Friend NotInheritable Class VisualBasicEmbeddedLanguagesProvider
         Inherits AbstractEmbeddedLanguagesProvider
 
         Public Shared ReadOnly Info As New EmbeddedLanguageInfo(
+            VisualBasicBlockFacts.Instance,
             VisualBasicSyntaxFacts.Instance,
             VisualBasicSemanticFactsService.Instance,
             VisualBasicVirtualCharService.Instance)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpBlockFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpBlockFactsService.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicBlockFactsService.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicBlockFactsService.vb
