Make it possible to analyze the dataflow of ConstructorInitializerSyntax

src/Compilers/CSharp/Portable/CSharpExtensions.cs

@@ -1032,6 +1032,24 @@ public static AwaitExpressionInfo GetAwaitExpressionInfo(this SemanticModel? sem
             return csmodel?.AnalyzeControlFlow(statement);
         }
 
+        /// <summary>
+        /// Analyze data-flow within a constructor initializer.
+        /// </summary>
+        public static DataFlowAnalysis? AnalyzeDataFlow(this SemanticModel? semanticModel, ConstructorInitializerSyntax constructorInitializer)
+        {
+            var csmodel = semanticModel as CSharpSemanticModel;
+            return csmodel?.AnalyzeDataFlow(constructorInitializer);
+        }
+
+        /// <summary>
+        /// Analyze data-flow within a primary-constructor-base-type initializer.
+        /// </summary>
+        public static DataFlowAnalysis? AnalyzeDataFlow(this SemanticModel? semanticModel, PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType)
+        {
+            var csmodel = semanticModel as CSharpSemanticModel;
+            return csmodel?.AnalyzeDataFlow(primaryConstructorBaseType);
+        }
+
         /// <summary>
         /// Analyze data-flow within an expression.
         /// </summary>

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -2411,6 +2411,28 @@ public virtual ControlFlowAnalysis AnalyzeControlFlow(StatementSyntax statement)
             return AnalyzeControlFlow(statement, statement);
         }
 
+        /// <summary>
+        /// Analyze data-flow within an ConstructorInitializerSyntax. 
+        /// </summary>
+        /// <param name="constructorInitializer">The ctor-init within the associated SyntaxTree to analyze.</param>
+        /// <returns>An object that can be used to obtain the result of the data flow analysis.</returns>
+        public virtual DataFlowAnalysis AnalyzeDataFlow(ConstructorInitializerSyntax constructorInitializer)
+        {
+            // Only supported on a SyntaxTreeSemanticModel.
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Analyze data-flow within an PrimaryConstructorBaseTypeSyntax. 
+        /// </summary>
+        /// <param name="primaryConstructorBaseType">The primary constructor base type within the associated SyntaxTree to analyze.</param>
+        /// <returns>An object that can be used to obtain the result of the data flow analysis.</returns>
+        public virtual DataFlowAnalysis AnalyzeDataFlow(PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType)
+        {
+            // Only supported on a SyntaxTreeSemanticModel.
+            throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Analyze data-flow within an expression. 
         /// </summary>
@@ -5245,8 +5267,12 @@ protected sealed override DataFlowAnalysis AnalyzeDataFlowCore(SyntaxNode statem
                     return this.AnalyzeDataFlow(statementSyntax);
                 case ExpressionSyntax expressionSyntax:
                     return this.AnalyzeDataFlow(expressionSyntax);
+                case ConstructorInitializerSyntax constructorInitializer:
+                    return this.AnalyzeDataFlow(constructorInitializer);
+                case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType:
+                    return this.AnalyzeDataFlow(primaryConstructorBaseType);
                 default:
-                    throw new ArgumentException("statementOrExpression is not a StatementSyntax or an ExpressionSyntax.");
+                    throw new ArgumentException("statementOrExpression is not a StatementSyntax or an ExpressionSyntax or a ConstructorInitializerSyntax or a PrimaryConstructorBaseTypeSyntax.");
             }
         }
 

src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs

@@ -2264,6 +2264,40 @@ public override DataFlowAnalysis AnalyzeDataFlow(ExpressionSyntax expression)
             return result;
         }
 
+        public override DataFlowAnalysis AnalyzeDataFlow(ConstructorInitializerSyntax constructorInitializer)
+        {
+            if (constructorInitializer == null)
+            {
+                throw new ArgumentNullException(nameof(constructorInitializer));
+            }
+
+            if (!IsInTree(constructorInitializer))
+            {
+                throw new ArgumentException("expression not within tree");
+            }
+
+            var context = RegionAnalysisContext(constructorInitializer);
+            var result = new CSharpDataFlowAnalysis(context);
+            return result;
+        }
+
+        public override DataFlowAnalysis AnalyzeDataFlow(PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType)
+        {
+            if (primaryConstructorBaseType == null)
+            {
+                throw new ArgumentNullException(nameof(primaryConstructorBaseType));
+            }
+
+            if (!IsInTree(primaryConstructorBaseType))
+            {
+                throw new ArgumentException("expression not within tree");
+            }
+
+            var context = RegionAnalysisContext(primaryConstructorBaseType);
+            var result = new CSharpDataFlowAnalysis(context);
+            return result;
+        }
+
         public override DataFlowAnalysis AnalyzeDataFlow(StatementSyntax firstStatement, StatementSyntax lastStatement)
         {
             ValidateStatementRange(firstStatement, lastStatement);

src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel_RegionAnalysisContext.cs

@@ -22,6 +22,12 @@ private RegionAnalysisContext RegionAnalysisContext(ExpressionSyntax expression)
             while (expression.Kind() == SyntaxKind.ParenthesizedExpression)
                 expression = ((ParenthesizedExpressionSyntax)expression).Expression;
 
+            return RegionAnalysisContext<ExpressionSyntax>(expression);
+        }
+
+        private RegionAnalysisContext RegionAnalysisContext<T>(T expression)
+            where T : CSharpSyntaxNode
+        {
             var memberModel = GetMemberModel(expression);
             if (memberModel == null)
             {

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -108,6 +108,8 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSynt
 override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
 override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer) -> Microsoft.CodeAnalysis.DataFlowAnalysis
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType) -> Microsoft.CodeAnalysis.DataFlowAnalysis
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax

src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowTestBase.cs

@@ -83,6 +83,16 @@ protected DataFlowAnalysis CompileAndAnalyzeDataFlowExpression(string program, p
             return CompileAndGetModelAndExpression(program, (model, expression) => model.AnalyzeDataFlow(expression), references);
         }
 
+        protected DataFlowAnalysis CompileAndAnalyzeDataFlowConstructorInitializer(string program, params MetadataReference[] references)
+        {
+            return CompileAndGetModelAndConstructorInitializer(program, (model, constructorInitializer) => model.AnalyzeDataFlow(constructorInitializer), references);
+        }
+
+        protected DataFlowAnalysis CompileAndAnalyzeDataFlowPrimaryConstructorInitializer(string program, params MetadataReference[] references)
+        {
+            return CompileAndGetModelAndPrimaryConstructorInitializer(program, (model, primaryConstructorInitializer) => model.AnalyzeDataFlow(primaryConstructorInitializer), references);
+        }
+
         protected DataFlowAnalysis CompileAndAnalyzeDataFlowStatements(string program)
         {
             return CompileAndGetModelAndStatements(program, (model, stmt1, stmt2) => model.AnalyzeDataFlow(stmt1, stmt2));
@@ -93,6 +103,48 @@ protected DataFlowAnalysis CompileAndAnalyzeDataFlowStatements(string program)
             return CompileAndGetModelAndStatements(program, (model, stmt1, stmt2) => (model.AnalyzeControlFlow(stmt1, stmt2), model.AnalyzeDataFlow(stmt1, stmt2)));
         }
 
+        protected T CompileAndGetModelAndConstructorInitializer<T>(string program, Func<SemanticModel, ConstructorInitializerSyntax, T> analysisDelegate, params MetadataReference[] references)
+        {
+            var comp = CreateCompilation(program, parseOptions: TestOptions.RegularPreview, references: references);
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            int start = program.IndexOf(StartString, StringComparison.Ordinal) + StartString.Length;
+            int end = program.IndexOf(EndString, StringComparison.Ordinal);
+            ConstructorInitializerSyntax syntaxToBind = null;
+            foreach (var expr in GetSyntaxNodeList(tree).OfType<ConstructorInitializerSyntax>())
+            {
+                if (expr.SpanStart >= start && expr.Span.End <= end)
+                {
+                    syntaxToBind = expr;
+                    break;
+                }
+            }
+
+            Assert.NotNull(syntaxToBind);
+            return analysisDelegate(model, syntaxToBind);
+        }
+
+        protected T CompileAndGetModelAndPrimaryConstructorInitializer<T>(string program, Func<SemanticModel, PrimaryConstructorBaseTypeSyntax, T> analysisDelegate, params MetadataReference[] references)
+        {
+            var comp = CreateCompilation(program, parseOptions: TestOptions.RegularPreview, references: references);
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            int start = program.IndexOf(StartString, StringComparison.Ordinal) + StartString.Length;
+            int end = program.IndexOf(EndString, StringComparison.Ordinal);
+            PrimaryConstructorBaseTypeSyntax syntaxToBind = null;
+            foreach (var expr in GetSyntaxNodeList(tree).OfType<PrimaryConstructorBaseTypeSyntax>())
+            {
+                if (expr.SpanStart >= start && expr.Span.End <= end)
+                {
+                    syntaxToBind = expr;
+                    break;
+                }
+            }
+
+            Assert.NotNull(syntaxToBind);
+            return analysisDelegate(model, syntaxToBind);
+        }
+
         protected T CompileAndGetModelAndExpression<T>(string program, Func<SemanticModel, ExpressionSyntax, T> analysisDelegate, params MetadataReference[] references)
         {
             var comp = CreateCompilation(program, parseOptions: TestOptions.RegularPreview, references: references);

src/Compilers/CSharp/Test/Semantic/FlowAnalysis/RegionAnalysisTests.cs

@@ -2618,6 +2618,202 @@ public static void M(C? c)
 
         #endregion
 
+        #region "constructor initalizer"
+        [Fact]
+        public void TestDataFlowsInCtorInitPublicApi()
+        {
+            var program = @"
+class C
+{
+    C(int x)
+    {}
+
+    C(int x, int y) /*<bind>*/ : this(x + y) /*</bind>*/
+    {}
+}
+";
+            var analysis = CompileAndGetModelAndConstructorInitializer(program,
+                (model, constructorInitializer) => CSharpExtensions.AnalyzeDataFlow(model, constructorInitializer)
+            );
+
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInCtorInitPublicApi2()
+        {
+            var program = @"
+class C
+{
+    C(int x)
+    {}
+
+    C(int x, int y) /*<bind>*/ : this(x + y) /*</bind>*/
+    {}
+}
+";
+            var analysis = CompileAndGetModelAndConstructorInitializer(program,
+                (model, constructorInitializer) => global::Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(model, constructorInitializer)
+            );
+
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInCtorInit()
+        {
+            var analysis = CompileAndAnalyzeDataFlowConstructorInitializer(@"
+class C
+{
+    C(int x)
+    {}
+
+    C(int x, int y) /*<bind>*/ : this(x + y) /*</bind>*/
+    {}
+}");
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInCtorInitVariablesDeclared()
+        {
+            var analysis = CompileAndAnalyzeDataFlowConstructorInitializer(@"
+class C
+{
+    C(int x)
+    {}
+
+    C(int x)
+    {}
+
+    C(int x, int y) /*<bind>*/ : this((x++ + y is var b) switch { _ => b * 2}) /*</bind>*/
+    {}
+}");
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+            Assert.Equal("x, b", GetSymbolNamesJoined(analysis.WrittenInside));
+            Assert.Equal("b", GetSymbolNamesJoined(analysis.VariablesDeclared));
+        }
+
+        [Fact]
+        public void TestDataFlowsInCtorInitComplex()
+        {
+            var analysis = CompileAndAnalyzeDataFlowConstructorInitializer(@"
+public class BaseX
+{
+	public BaseX(out int ix, ref string i, in int s, in int s2, out int rrr)
+	{
+	}
+}
+
+public class X : BaseX
+{
+	public X(int r, out int ix, out int x, ref int i)/*<bind>*/  : 
+		base(out ix, ref CalcValue(""ctor"", out x), CalcInt(""int"", out var y) + CalcInt(""int2"", out var y2),
+        x + y + r + y2 + i++, out var rrr)
+        /*</bind>*/
+    {
+        Console.WriteLine(y);
+    }
+
+    static string s;
+    static ref string CalcValue(string text, out int i)
+    {
+        Console.WriteLine($""CalcInt({text})"");
+        i = 42;
+        return ref s;
+    }
+
+        static int CalcInt(string text, out int i)
+        {
+            Console.WriteLine($""CalcInt({text})"");
+            i = 42;
+            return i;
+        }
+}");
+            Assert.Equal("r, i", GetSymbolNamesJoined(analysis.DataFlowsIn));
+            Assert.Equal("ix, x, i, y", GetSymbolNamesJoined(analysis.DataFlowsOut));
+            Assert.Equal("r, x, i, y, y2", GetSymbolNamesJoined(analysis.ReadInside));
+            Assert.Equal("ix, x, i, y", GetSymbolNamesJoined(analysis.ReadOutside));
+            Assert.Equal("ix, x, i, y, y2, rrr", GetSymbolNamesJoined(analysis.WrittenInside));
+            Assert.Equal("ix, x, i, y, y2, rrr", GetSymbolNamesJoined(analysis.AlwaysAssigned));
+            Assert.Equal("this, r, i", GetSymbolNamesJoined(analysis.WrittenOutside));
+            Assert.Equal("y, y2, rrr", GetSymbolNamesJoined(analysis.VariablesDeclared));
+        }
+
+        [Fact]
+        public void TestDataFlowsInCtorInitWrite()
+        {
+            var analysis = CompileAndAnalyzeDataFlowConstructorInitializer(@"
+class C
+{
+    C(int x)
+    {}
+
+    C(int x, int y) /*<bind>*/ : this(x++ + y) /*</bind>*/
+    {}
+}");
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+            Assert.Equal("x", GetSymbolNamesJoined(analysis.WrittenInside));
+        }
+        #endregion
+
+        #region "primary constructor initalizer"
+
+        [Fact]
+        public void TestDataFlowsInPrimaryCtorInitPublicApi()
+        {
+            var program = @"
+record Base(int x)
+
+record C(int x, int y) /*<bind>*/ : Base(x + y) /*</bind>*/;
+";
+            var analysis = CompileAndGetModelAndPrimaryConstructorInitializer(program,
+                (model, primaryConstructorInitializer) => CSharpExtensions.AnalyzeDataFlow(model, primaryConstructorInitializer)
+            );
+
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInPrimaryCtorInitPublicApi2()
+        {
+            var program = @"
+record Base(int x)
+
+record C(int x, int y) /*<bind>*/ : Base(x + y) /*</bind>*/;
+";
+            var analysis = CompileAndGetModelAndPrimaryConstructorInitializer(program,
+                (model, primaryConstructorInitializer) => global::Microsoft.CodeAnalysis.ModelExtensions.AnalyzeDataFlow(model, primaryConstructorInitializer)
+            );
+
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInPrimaryCtorInit()
+        {
+            var analysis = CompileAndAnalyzeDataFlowPrimaryConstructorInitializer(@"
+record Base(int x)
+
+record C(int x, int y) /*<bind>*/ : Base(x + y) /*</bind>*/;
+");
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+        }
+
+        [Fact]
+        public void TestDataFlowsInPrimaryCtorInitVariablesDeclared()
+        {
+            var analysis = CompileAndAnalyzeDataFlowPrimaryConstructorInitializer(@"
+record Base(int x);
+
+record C(int x, int y) /*<bind>*/ : Base((x++ + y is var b) switch { _ => b * 2}) /*</bind>*/;
+");
+            Assert.Equal("x, y", GetSymbolNamesJoined(analysis.DataFlowsIn));
+            Assert.Equal("x, b", GetSymbolNamesJoined(analysis.WrittenInside));
+            Assert.Equal("b", GetSymbolNamesJoined(analysis.VariablesDeclared));
+        }
+        #endregion
+
         #region "Statements"
 
         [Fact]