Don't instrument local declarations without initializers.

src/Compilers/CSharp/Portable/Compiler/Instrumentation.cs

@@ -185,17 +185,19 @@ public override BoundNode Visit(BoundNode node)
                     case BoundKind.ForStatement:
                         return visited;
                     case BoundKind.ReturnStatement:
+                        // A synthesized return statement that does not return a value never requires instrumentation.
+                        // A property set method defined without a block has such a synthesized return statement.
                         if (!_methodHasExplicitBlock && ((BoundReturnStatement)statement).ExpressionOpt != null)
                         {
                             // The return statement for value-returning methods defined without a block is compiler generated, but requires instrumentation.
-                            return ForceCollectDynamicAnalysis(visited);
+                            return CollectDynamicAnalysis(visited);
                         }
                         break;
                     case BoundKind.ExpressionStatement:
                         if (!_methodHasExplicitBlock)
                         {
                             // The assignment statement for a property set method defined without a block is compiler generated, but requires instrumentation.
-                            return ForceCollectDynamicAnalysis(visited);
+                            return CollectDynamicAnalysis(visited);
                         }
                         break;
                     case BoundKind.LocalDeclaration:
@@ -226,6 +228,13 @@ public override BoundNode Visit(BoundNode node)
                                     break;
                             }
                         }
+
+                        // Declarations without initializers are not instrumented.
+                        if (!HasInitializer((BoundLocalDeclaration)statement))
+                        {
+                            return visited;
+                        }
+
                         break;
                     case BoundKind.MultipleLocalDeclarations:
                         // Using and fixed statements have a multiple local declarations node even if they contain only one declaration.
@@ -246,44 +255,58 @@ public override BoundNode Visit(BoundNode node)
                                 }
                                 break;
                         }
+
+                        // Declarations without initializers are not instrumented.
+                        // Ultimately the individual initializers will be implemented, but for now instrument the statement if it has any initializers.
+                        if (!HasInitializer((BoundMultipleLocalDeclarations)statement))
+                        {
+                            return visited;
+                        }
+
                         break;
                     default:
                         break;
                 }
 
-                return CollectDynamicAnalysis(visited);
+                if (!statement.WasCompilerGenerated)
+                {
+                    return CollectDynamicAnalysis(visited);
+                }
             }
 
             return visited;
         }
         
-        private BoundNode CollectDynamicAnalysis(BoundNode node)
+        private static bool HasInitializer(BoundLocalDeclaration local)
         {
-            BoundStatement statement = node as BoundStatement;
-            if (statement != null)
-            {
-                return CollectDynamicAnalysis(statement);
-            }
-
-            return node;
+            return local.InitializerOpt != null;
         }
 
-        private BoundNode CollectDynamicAnalysis(BoundStatement statement)
+        private static bool HasInitializer(BoundMultipleLocalDeclarations multiple)
         {
-            if (statement.WasCompilerGenerated)
+            foreach (BoundLocalDeclaration local in multiple.LocalDeclarations)
             {
-                return statement;
+                if (HasInitializer(local))
+                {
+                    return true;
+                }
             }
 
-            return CollectDynamicAnalysisCore(statement);
+            return false;
         }
 
-        private BoundNode ForceCollectDynamicAnalysis(BoundNode node)
+        private BoundNode CollectDynamicAnalysis(BoundNode node)
         {
-            return CollectDynamicAnalysisCore((BoundStatement)node);
+            BoundStatement statement = node as BoundStatement;
+            if (statement != null)
+            {
+                return CollectDynamicAnalysis(statement);
+            }
+
+            return node;
         }
 
-        private BoundNode CollectDynamicAnalysisCore(BoundStatement statement)
+        private BoundNode CollectDynamicAnalysis(BoundStatement statement)
         {
             // Add an entry in the spans array.
 

src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs

@@ -260,6 +260,8 @@ public static void Main(string[] args)
 
     static void TestMain()
     {
+        int x;
+        int a, b;
         DoubleDeclaration(5);
         DoubleForDeclaration(5);
     }
@@ -268,9 +270,10 @@ static int DoubleDeclaration(int x)
     {
         int c = x;
         int a, b;
-        a = b = c;
+        int f;
+        a = b = f = c;
         int d = a, e = b;
-        return d + e;
+        return d + e + f;
     }
 
     static int DoubleForDeclaration(int x)
@@ -295,7 +298,6 @@ static int DoubleForDeclaration(int x)
 True
 True
 True
-True
 4
 True
 False
@@ -613,7 +615,7 @@ async static Task<string> First(string s)
 
     async static Task<string> Second(string s)
     {
-        string doubled;
+        string doubled = """";
         if (s.Length > 2)
             doubled = s + s;
         else