Revert signature change

dotnet · Oct 4, 2024 · 8fde573 · 8fde573
1 parent 0da3c4a
commit 8fde573
Show file tree

Hide file tree

Showing 17 changed files with 26 additions and 44 deletions.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.cs b/src/Compilers/CSharp/Portable/Binder/Binder.cs
@@ -475,12 +475,12 @@ internal virtual ConsList<FieldSymbol> FieldsBeingBound
             }
         }
 
-        internal virtual ConsList<LocalSymbol> LocalsInProgress
+        internal virtual LocalSymbol? LocalInProgress
         {
             get
             {
                 RoslynDebug.Assert(Next is object);
-                return this.Next.LocalsInProgress;
+                return this.Next.LocalInProgress;
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Deconstruct.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Deconstruct.cs
@@ -867,10 +867,10 @@ private BoundExpression BindDeconstructionVariable(
             CSharpSyntaxNode syntax,
             BindingDiagnosticBag diagnostics)
         {
-            SourceLocalSymbol? localSymbol = LookupLocal(designation.Identifier);
+            SourceLocalSymbol localSymbol = LookupLocal(designation.Identifier);
 
             // is this a local?
-            if ((object?)localSymbol != null)
+            if ((object)localSymbol != null)
             {
                 if (designation.Parent is DeclarationExpressionSyntax declExpr && declExpr.Designation == designation)
                 {

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -2065,7 +2065,7 @@ private BoundExpression BindNonMethod(SimpleNameSyntax node, Symbol symbol, Bind
                         }
 
                         var constantValueOpt = localSymbol.IsConst && !IsInsideNameof && !type.IsErrorType()
-                            ? localSymbol.GetConstantValue(node, this.LocalsInProgress, diagnostics) : null;
+                            ? localSymbol.GetConstantValue(node, this.LocalInProgress, diagnostics) : null;
                         return new BoundLocal(node, localSymbol, BoundLocalDeclarationKind.None, constantValueOpt: constantValueOpt, isNullableUnknown: isNullableUnknown, type: type, hasErrors: isError);
                     }
 

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs
@@ -876,7 +876,7 @@ private void BindPatternDesignation(
             {
                 case SingleVariableDesignationSyntax singleVariableDesignation:
                     SyntaxToken identifier = singleVariableDesignation.Identifier;
-                    SourceLocalSymbol? localSymbol = this.LookupLocal(identifier);
+                    SourceLocalSymbol localSymbol = this.LookupLocal(identifier);
 
                     if (!permitDesignations && !identifier.IsMissing)
                         diagnostics.Add(ErrorCode.ERR_DesignatorBeneathPatternCombinator, identifier.GetLocation());

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -956,7 +956,8 @@ protected BoundLocalDeclaration BindVariableDeclaration(
             CSharpSyntaxNode associatedSyntaxNode = null)
         {
             Debug.Assert(declarator != null);
-            return this.BindVariableDeclaration(LocateDeclaredVariableSymbol(declarator, typeSyntax, kind),
+
+            return BindVariableDeclaration(LocateDeclaredVariableSymbol(declarator, typeSyntax, kind),
                                            kind,
                                            isVar,
                                            declarator,
@@ -1844,13 +1845,10 @@ private BoundExpression BindPossibleArrayInitializer(
             return CheckValue(result, valueKind, diagnostics);
         }
 
-#nullable enable
-        protected virtual SourceLocalSymbol? LookupLocal(SyntaxToken nameToken)
+        protected virtual SourceLocalSymbol LookupLocal(SyntaxToken nameToken)
         {
-            Debug.Assert(Next is not null);
             return Next.LookupLocal(nameToken);
         }
-#nullable disable
 
         protected virtual LocalFunctionSymbol LookupLocalFunction(SyntaxToken nameToken)
         {

diff --git a/src/Compilers/CSharp/Portable/Binder/BuckStopsHereBinder.cs b/src/Compilers/CSharp/Portable/Binder/BuckStopsHereBinder.cs
@@ -86,11 +86,11 @@ internal override ConsList<FieldSymbol> FieldsBeingBound
             }
         }
 
-        internal override ConsList<LocalSymbol> LocalsInProgress
+        internal override LocalSymbol? LocalInProgress
         {
             get
             {
-                return ConsList<LocalSymbol>.Empty;
+                return null;
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/Binder/LocalInProgressBinder.cs b/src/Compilers/CSharp/Portable/Binder/LocalInProgressBinder.cs
@@ -27,17 +27,11 @@ internal LocalInProgressBinder(EqualsValueClauseSyntax initializerSyntax, Binder
             InitializerSyntax = initializerSyntax;
         }
 
-        internal override ConsList<LocalSymbol> LocalsInProgress
+        internal override LocalSymbol? LocalInProgress
         {
             get
             {
-                var result = base.LocalsInProgress;
-                if (_localSymbol is not null)
-                {
-                    return result.Push(_localSymbol);
-                }
-
-                return result;
+                return _localSymbol;
             }
         }
 

diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -2403,7 +2403,7 @@ public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
             get { throw new NotImplementedException(); }
         }
 
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             throw new NotImplementedException();
         }

diff --git a/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
@@ -334,10 +334,6 @@ private static Binder GetEnclosingBinderInternalWithinRoot(SyntaxNode node, int
                 {
                     binder = rootBinder.GetBinder(current);
                 }
-                else if (kind == SyntaxKind.VariableDeclarator)
-                {
-                    binder = rootBinder.GetBinder(current);
-                }
                 else if ((current as ExpressionSyntax).IsValidScopeDesignator())
                 {
                     binder = rootBinder.GetBinder(current);

diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.PlaceholderLocal.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.PlaceholderLocal.cs
@@ -58,7 +58,7 @@ public override bool Equals(Symbol obj, TypeCompareKind compareKind)
             internal override bool IsKnownToReferToTempIfReferenceType => false;
             public override RefKind RefKind => RefKind.None;
             internal override SynthesizedLocalKind SynthesizedKind => throw ExceptionUtilities.Unreachable();
-            internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics = null) => null;
+            internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null) => null;
             internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) => ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty;
             internal override SyntaxNode GetDeclaratorSyntax() => throw ExceptionUtilities.Unreachable();
             internal override bool HasSourceLocation => false;

diff --git a/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs
@@ -358,9 +358,7 @@ internal abstract bool IsCompilerGenerated
             get;
         }
 
-#nullable enable
-        internal abstract ConstantValue? GetConstantValue(SyntaxNode node, ConsList<LocalSymbol>? inProgress, BindingDiagnosticBag? diagnostics = null);
-#nullable disable
+        internal abstract ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null);
 
         internal abstract ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue);
 

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
@@ -467,7 +467,7 @@ internal override bool IsCompilerGenerated
             get { return false; }
         }
 
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             return null;
         }
@@ -547,24 +547,22 @@ protected override TypeWithAnnotations InferTypeOfVarVariable(BindingDiagnosticB
 
             internal override SyntaxNode ForbiddenZone => _initializer;
 
-#nullable enable
             /// <summary>
             /// Determine the constant value of this local and the corresponding diagnostics.
             /// Set both to constantTuple in a single operation for thread safety.
             /// </summary>
             /// <param name="inProgress">Null for the initial call, non-null if we are in the process of evaluating a constant.</param>
             /// <param name="boundInitValue">If we already have the bound node for the initial value, pass it in to avoid recomputing it.</param>
-            private void MakeConstantTuple(ConsList<LocalSymbol>? inProgress, BoundExpression? boundInitValue)
+            private void MakeConstantTuple(LocalSymbol inProgress, BoundExpression boundInitValue)
             {
                 if (this.IsConst && _constantTuple == null)
                 {
                     var value = Microsoft.CodeAnalysis.ConstantValue.Bad;
                     var diagnostics = BindingDiagnosticBag.GetInstance();
-                    Debug.Assert(inProgress?.Contains(this) != true);
+                    Debug.Assert(inProgress != this);
                     var type = this.Type;
                     if (boundInitValue == null)
                     {
-                        // TODO2
                         recordLocalInBinderChain(this, _initializer, this._initializerBinder);
                         boundInitValue = this._initializerBinder.BindVariableOrAutoPropInitializerValue(_initializer, this.RefKind, type, diagnostics);
                     }
@@ -588,9 +586,9 @@ static void recordLocalInBinderChain(LocalSymbol local, EqualsValueClauseSyntax
                 }
             }
 
-            internal override ConstantValue? GetConstantValue(SyntaxNode node, ConsList<LocalSymbol>? inProgress, BindingDiagnosticBag? diagnostics = null)
+            internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null)
             {
-                if (this.IsConst && inProgress?.Contains(this) == true)
+                if (this.IsConst && inProgress == this)
                 {
                     if (diagnostics != null)
                     {
@@ -610,7 +608,6 @@ internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiag
                 MakeConstantTuple(inProgress: null, boundInitValue: boundInitValue);
                 return _constantTuple == null ? ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty : _constantTuple.Diagnostics;
             }
-#nullable disable
         }
 
         /// <summary>

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs
@@ -9,7 +9,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -188,7 +187,7 @@ internal sealed override bool IsCompilerGenerated
 
         internal sealed override ScopedKind Scope => ScopedKind.None;
 
-        internal sealed override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal sealed override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             return null;
         }

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs
@@ -113,7 +113,7 @@ public override RefKind RefKind
         /// </summary>
         internal override ScopedKind Scope => throw new System.NotImplementedException();
 
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             return _originalVariable.GetConstantValue(node, inProgress, diagnostics);
         }

diff --git a/src/Compilers/CSharp/Portable/Symbols/UpdatedContainingSymbolLocal.cs b/src/Compilers/CSharp/Portable/Symbols/UpdatedContainingSymbolLocal.cs
@@ -90,7 +90,7 @@ public override bool Equals(Symbol other, TypeCompareKind compareKind)
         internal override bool IsKnownToReferToTempIfReferenceType => _underlyingLocal.IsKnownToReferToTempIfReferenceType;
         internal override bool IsCompilerGenerated => _underlyingLocal.IsCompilerGenerated;
         internal override ScopedKind Scope => _underlyingLocal.Scope;
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol>? inProgress, BindingDiagnosticBag? diagnostics = null) =>
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag? diagnostics = null) =>
             _underlyingLocal.GetConstantValue(node, inProgress, diagnostics);
         internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) =>
             _underlyingLocal.GetConstantValueDiagnostics(boundInitValue);

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalConstantSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalConstantSymbol.cs
@@ -84,7 +84,7 @@ internal override bool IsCompilerGenerated
             get { return false; }
         }
 
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             if (diagnostics != null && _value.IsBad)
             {

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs
@@ -33,7 +33,7 @@ internal abstract class EELocalSymbolBase : LocalSymbol
 
         internal abstract EELocalSymbolBase ToOtherMethod(MethodSymbol method, TypeMap typeMap);
 
-        internal override ConstantValue GetConstantValue(SyntaxNode node, ConsList<LocalSymbol> inProgress, BindingDiagnosticBag diagnostics)
+        internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)
         {
             return null;
         }