dotnet · CyrusNajmabadi · Dec 3, 2022 · Nov 14, 2022 · Nov 14, 2022 · Nov 14, 2022
@@ -761,7 +761,7 @@ private DeconstructionVariable BindDeconstructionVariables(
                         bool isVar;
                         bool isConst = false;
                         AliasSymbol alias;
-                        var declType = BindVariableTypeWithAnnotations(component.Designation, diagnostics, component.Type.SkipScoped(out _).SkipRef(out _), ref isConst, out isVar, out alias);
+                        var declType = BindVariableTypeWithAnnotations(component.Designation, diagnostics, component.Type.SkipScoped(out _).SkipRef(), ref isConst, out isVar, out alias);
                         Debug.Assert(isVar == !declType.HasType);
                         if (component.Designation.Kind() == SyntaxKind.ParenthesizedVariableDesignation)
                         {

@@ -892,7 +892,7 @@ private BoundExpression BindDeclarationExpressionAsError(DeclarationExpressionSy
             bool isVar;
             bool isConst = false;
             AliasSymbol alias;
-            var declType = BindVariableTypeWithAnnotations(node.Designation, diagnostics, node.Type.SkipScoped(out _).SkipRef(out _), ref isConst, out isVar, out alias);
+            var declType = BindVariableTypeWithAnnotations(node.Designation, diagnostics, node.Type.SkipScoped(out _).SkipRef(), ref isConst, out isVar, out alias);
             Error(diagnostics, ErrorCode.ERR_DeclarationExpressionNotPermitted, node);
             return BindDeclarationVariablesForErrorRecovery(declType, node.Designation, node, diagnostics);
         }

@@ -282,8 +282,8 @@ static void checkAttributes(AnonymousFunctionExpressionSyntax syntax, SyntaxList
             MessageID.IDS_FeatureLambdaReturnType.CheckFeatureAvailability(diagnostics, syntax);
 
             Debug.Assert(syntax is not ScopedTypeSyntax);
-            syntax = syntax.SkipScoped(out _).SkipRef(out RefKind refKind);
-            if ((syntax as IdentifierNameSyntax)?.Identifier.ContextualKind() == SyntaxKind.VarKeyword)
+            syntax = syntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind);
+            if (syntax is IdentifierNameSyntax { Identifier.RawContextualKind: (int)SyntaxKind.VarKeyword })
             {
                 diagnostics.Add(ErrorCode.ERR_LambdaExplicitReturnTypeVar, syntax.Location);
             }

@@ -713,7 +713,10 @@ private BoundStatement BindDeclarationStatementParts(LocalDeclarationStatementSy
                 typeSyntax = scopedType.Type;
             }
 
-            typeSyntax = typeSyntax.SkipRef(out _);
+            // Slightly odd, but we unwrap ref here (and report a lang-version diagnostic when appropriate).  Ideally,
+            // this would be in the constructor of SourceLocalSymbol, but it lacks a diagnostics bag passed to it to add
+            // this diagnostic.
+            typeSyntax = typeSyntax.SkipRefInLocalOrReturn(diagnostics, out _);
 
             bool isVar;
             AliasSymbol alias;
@@ -795,7 +798,7 @@ declarationNode is VariableDesignationSyntax ||
             // we want to treat the declaration as an explicitly typed declaration.
 
             Debug.Assert(typeSyntax is not ScopedTypeSyntax);
-            TypeWithAnnotations declType = BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRef(out _), diagnostics, out isVar, out alias);
+            TypeWithAnnotations declType = BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRef(), diagnostics, out isVar, out alias);
             Debug.Assert(declType.HasType || isVar);
 
             if (isVar)
@@ -2726,7 +2729,7 @@ internal BoundStatement BindForOrUsingOrFixedDeclarations(VariableDeclarationSyn
             // Fixed and using variables are not allowed to be ref-like, but regular variables are
             if (localKind == LocalDeclarationKind.RegularVariable)
             {
-                typeSyntax = typeSyntax.SkipRef(out _);
+                typeSyntax = typeSyntax.SkipRef();
             }
 
             AliasSymbol alias;

@@ -75,7 +75,11 @@ private BoundForStatement BindForParts(ForStatementSyntax node, Binder originalB
                 var type = _syntax.Declaration.Type.SkipScoped(out _);
 
                 if (type is RefTypeSyntax)
+                {
+                    // Checking for 'ref for' (7.3) automatically checks for 'ref' (7.0), so no need for an explicit
+                    // check feature as well here.
                     MessageID.IDS_FeatureRefFor.CheckFeatureAvailability(diagnostics, type);
+                }
 
                 initializer = originalBinder.BindForOrUsingOrFixedDeclarations(node.Declaration, LocalDeclarationKind.RegularVariable, diagnostics, out _);
             }

@@ -67,7 +67,7 @@ internal BoundExpression SetInferredTypeWithAnnotations(TypeWithAnnotations type
                             if (localSymbol.Scope == DeclarationScope.ValueScoped && !type.Type.IsErrorTypeOrRefLikeType())
                             {
                                 diagnosticsOpt.Add(ErrorCode.ERR_ScopedRefAndRefStructOnly,
-                                                   (typeOrDesignationSyntax is TypeSyntax typeSyntax ? typeSyntax.SkipScoped(out _).SkipRef(out _) : typeOrDesignationSyntax).Location);
+                                                   (typeOrDesignationSyntax is TypeSyntax typeSyntax ? typeSyntax.SkipScoped(out _).SkipRef() : typeOrDesignationSyntax).Location);
                             }
                         }
                     }

@@ -7165,19 +7165,10 @@ private TypeSyntax ParseType(ParseTypeMode mode = ParseTypeMode.Normal)
         {
             if (this.CurrentToken.Kind == SyntaxKind.RefKeyword)
             {
-                var refKeyword = this.EatToken();
-                refKeyword = this.CheckFeatureAvailability(refKeyword, MessageID.IDS_FeatureRefLocalsReturns);
-
-                SyntaxToken readonlyKeyword = null;
-                if (this.CurrentToken.Kind == SyntaxKind.ReadOnlyKeyword)
-                {
-                    readonlyKeyword = this.EatToken();
-                    readonlyKeyword = this.CheckFeatureAvailability(readonlyKeyword, MessageID.IDS_FeatureReadOnlyReferences);
-                }
-
-                var type = ParseTypeCore(ParseTypeMode.AfterRef);
-
-                return _syntaxFactory.RefType(refKeyword, readonlyKeyword, type);
+                return _syntaxFactory.RefType(
+                    this.EatToken(),
+                    this.CurrentToken.Kind == SyntaxKind.ReadOnlyKeyword ? this.EatToken() : null,
+                    ParseTypeCore(ParseTypeMode.AfterRef));
             }
 
             return ParseTypeCore(mode);

@@ -50,7 +50,7 @@ internal static GlobalExpressionVariable Create(
             Debug.Assert(nodeToBind.Kind() == SyntaxKind.VariableDeclarator || nodeToBind is ExpressionSyntax);
 
             var syntaxReference = syntax.GetReference();
-            return (typeSyntax == null || typeSyntax.SkipScoped(out _).SkipRef(out _).IsVar)
+            return (typeSyntax == null || typeSyntax.SkipScoped(out _).SkipRef().IsVar)
                 ? new InferrableGlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location, containingFieldOpt, nodeToBind)
                 : new GlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location);
         }
@@ -88,7 +88,7 @@ internal override TypeWithAnnotations GetFieldType(ConsList<FieldSymbol> fieldsB
 
             if (typeSyntax != null)
             {
-                type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRef(out _), diagnostics, out isVar);
+                type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRef(), diagnostics, out isVar);
             }
             else
             {

@@ -73,23 +73,7 @@ public LocalFunctionSymbol(
                 ReportAttributesDisallowed(param.AttributeLists, _declarationDiagnostics);
             }
 
-            if (syntax.ReturnType.Kind() == SyntaxKind.RefType)
-            {
-                var returnType = (RefTypeSyntax)syntax.ReturnType;
-                if (returnType.ReadOnlyKeyword.Kind() == SyntaxKind.ReadOnlyKeyword)
-                {
-                    _refKind = RefKind.RefReadOnly;
-                }
-                else
-                {
-                    _refKind = RefKind.Ref;
-                }
-            }
-            else
-            {
-                _refKind = RefKind.None;
-            }
-
+            syntax.ReturnType.SkipRefInLocalOrReturn(_declarationDiagnostics, out _refKind);
             _binder = binder;
         }
 
@@ -235,7 +219,7 @@ internal void ComputeReturnType()
             var diagnostics = BindingDiagnosticBag.GetInstance(_declarationDiagnostics);
             TypeSyntax returnTypeSyntax = Syntax.ReturnType;
             Debug.Assert(returnTypeSyntax is not ScopedTypeSyntax);
-            TypeWithAnnotations returnType = WithTypeParametersBinder.BindType(returnTypeSyntax.SkipScoped(out _).SkipRef(out _), diagnostics);
+            TypeWithAnnotations returnType = WithTypeParametersBinder.BindType(returnTypeSyntax.SkipScoped(out _).SkipRef(), diagnostics);
 
             var compilation = DeclaringCompilation;
 

@@ -47,7 +47,7 @@ internal static void AddDelegateMembers(
             TypeSyntax returnTypeSyntax = syntax.ReturnType;
             Debug.Assert(returnTypeSyntax is not ScopedTypeSyntax);
 
-            returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRef(out RefKind refKind);
+            returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind);
             var returnType = binder.BindType(returnTypeSyntax, diagnostics);
 
             // reuse types to avoid reporting duplicate errors if missing:

@@ -71,23 +71,18 @@ private SourceLocalSymbol(
             typeSyntax = typeSyntax.SkipScoped(out isScoped);
             isScoped = isScoped && allowScoped;
 
-            if (allowRefKind && typeSyntax is RefTypeSyntax refTypeSyntax)
-            {
-                this._refKind = refTypeSyntax.ReadOnlyKeyword.Kind() == SyntaxKind.ReadOnlyKeyword ?
-                    RefKind.RefReadOnly :
-                    RefKind.Ref;
-                this._scope = isScoped ? DeclarationScope.RefScoped : DeclarationScope.Unscoped;
-            }
-            else
-            {
-                this._refKind = RefKind.None;
-                this._scope = isScoped ? DeclarationScope.ValueScoped : DeclarationScope.Unscoped;
-            }
+            // Diagnostics for ref-locals is reported by caller in BindDeclarationStatementParts.
+            if (allowRefKind)
+                typeSyntax.SkipRefInLocalOrReturn(diagnostics: null, out _refKind);
+
+            _scope = _refKind != RefKind.None
+                ? isScoped ? DeclarationScope.RefScoped : DeclarationScope.Unscoped
+                : isScoped ? DeclarationScope.ValueScoped : DeclarationScope.Unscoped;
 
             this._declarationKind = declarationKind;
 
             // create this eagerly as it will always be needed for the EnsureSingleDefinition
-            _locations = ImmutableArray.Create<Location>(identifierToken.GetLocation());
+            _locations = ImmutableArray.Create(identifierToken.GetLocation());
 
             _refEscapeScope = this._refKind == RefKind.None ?
                                         scopeBinder.LocalScopeDepth :
@@ -208,7 +203,7 @@ public static SourceLocalSymbol MakeDeconstructionLocal(
             Debug.Assert(closestTypeSyntax != null);
             Debug.Assert(nodeBinder != null);
 
-            return closestTypeSyntax.SkipScoped(out _).SkipRef(out _).IsVar
+            return closestTypeSyntax.SkipScoped(out _).SkipRef().IsVar
                 ? new DeconstructionLocalSymbol(containingSymbol, scopeBinder, nodeBinder, closestTypeSyntax, identifierToken, kind, deconstruction)
                 : new SourceLocalSymbol(containingSymbol, scopeBinder, allowRefKind: false, allowScoped: true, closestTypeSyntax, identifierToken, kind);
         }
@@ -239,7 +234,7 @@ internal static LocalSymbol MakeLocalSymbolWithEnclosingContext(
                         Contains(nodeToBind.Ancestors().OfType<StatementSyntax>().First().Kind()) ||
                 nodeToBind is ExpressionSyntax);
             Debug.Assert(!(nodeToBind.Kind() == SyntaxKind.SwitchExpressionArm) || nodeBinder is SwitchExpressionArmBinder);
-            return typeSyntax?.SkipScoped(out _).SkipRef(out _).IsVar != false && kind != LocalDeclarationKind.DeclarationExpressionVariable
+            return typeSyntax?.SkipScoped(out _).SkipRef().IsVar != false && kind != LocalDeclarationKind.DeclarationExpressionVariable
                 ? new LocalSymbolWithEnclosingContext(containingSymbol, scopeBinder, nodeBinder, typeSyntax, identifierToken, kind, nodeToBind, forbiddenZone)
                 : new SourceLocalSymbol(containingSymbol, scopeBinder, allowRefKind: false, allowScoped: true, typeSyntax, identifierToken, kind);
         }
@@ -383,7 +378,7 @@ public bool IsVar
                     return true;
                 }
 
-                TypeSyntax typeSyntax = _typeSyntax.SkipScoped(out _).SkipRef(out _);
+                TypeSyntax typeSyntax = _typeSyntax.SkipScoped(out _).SkipRef();
 
                 if (typeSyntax.IsVar)
                 {
@@ -419,7 +414,7 @@ private TypeWithAnnotations GetTypeSymbol()
             }
             else
             {
-                declType = typeBinder.BindTypeOrVarKeyword(_typeSyntax.SkipScoped(out _).SkipRef(out _), diagnostics, out isVar);
+                declType = typeBinder.BindTypeOrVarKeyword(_typeSyntax.SkipScoped(out _).SkipRef(), diagnostics, out isVar);
             }
 
             if (isVar)

@@ -4477,7 +4477,8 @@ private void AddNonTypeMembers(
                         {
                             var fieldSyntax = (FieldDeclarationSyntax)m;
 
-                            _ = fieldSyntax.Declaration.Type.SkipScoped(out _).SkipRef(out RefKind refKind);
+                            // Lang version check for ref-fields is done inside SourceMemberFieldSymbol;
+                            _ = fieldSyntax.Declaration.Type.SkipScoped(out _).SkipRefInField(out var refKind);
 
                             if (IsImplicitClass && reportMisplacedGlobalCode)
                             {

@@ -489,31 +489,26 @@ private TypeAndRefKind GetTypeAndRefKind(ConsList<FieldSymbol> fieldsBeingBound)
                 binder = binder.WithAdditionalFlagsAndContainingMemberOrLambda(BinderFlags.SuppressConstraintChecks, this);
                 if (!ContainingType.IsScriptClass)
                 {
-                    var typeOnly = typeSyntax.SkipScoped(out _).SkipRef(out refKind);
+                    var typeOnly = typeSyntax.SkipScoped(out _).SkipRefInField(out refKind);
                     Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly);
                     type = binder.BindType(typeOnly, diagnosticsForFirstDeclarator);
                     if (refKind != RefKind.None)
                     {
                         MessageID.IDS_FeatureRefFields.CheckFeatureAvailability(diagnostics, compilation, typeSyntax.SkipScoped(out _).Location);
                         if (!compilation.Assembly.RuntimeSupportsByRefFields)
-                        {
                             diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportRefFields, ErrorLocation);
-                        }
 
                         if (!containingType.IsRefLikeType)
-                        {
                             diagnostics.Add(ErrorCode.ERR_RefFieldInNonRefStruct, ErrorLocation);
-                        }
+
                         if (type.Type?.IsRefLikeType == true)
-                        {
                             diagnostics.Add(ErrorCode.ERR_RefFieldCannotReferToRefStruct, typeSyntax.SkipScoped(out _).Location);
-                        }
                     }
                 }
                 else
                 {
                     bool isVar;
-                    type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRef(out RefKind refKindToAssert), diagnostics, out isVar);
+                    type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRefInField(out RefKind refKindToAssert), diagnostics, out isVar);
                     Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error
                     Debug.Assert(type.HasType || isVar);
 

@@ -99,7 +99,7 @@ private SourceOrdinaryMethodSymbol(
             bool hasBody = hasBlockBody || _isExpressionBodied;
             _hasAnyBody = hasBody;
             Debug.Assert(syntax.ReturnType is not ScopedTypeSyntax);
-            _refKind = syntax.ReturnType.SkipScoped(out _).GetRefKind();
+            _refKind = syntax.ReturnType.SkipScoped(out _).GetRefKindInLocalOrReturn(diagnostics);
 
             CheckForBlockAndExpressionBody(
                 syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
@@ -144,7 +144,7 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
             var returnTypeSyntax = syntax.ReturnType;
             Debug.Assert(returnTypeSyntax is not ScopedTypeSyntax);
 
-            returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRef(out RefKind refKind);
+            returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRef();
             TypeWithAnnotations returnType = signatureBinder.BindType(returnTypeSyntax, diagnostics);
 
             // span-like types are returnable in general

@@ -109,7 +109,7 @@ private SourcePropertySymbol(
                 isAutoProperty: isAutoProperty,
                 isExpressionBodied: isExpressionBodied,
                 isInitOnly: isInitOnly,
-                syntax.Type.SkipScoped(out _).GetRefKind(),
+                syntax.Type.SkipScoped(out _).GetRefKindInLocalOrReturn(diagnostics),
                 memberName,
                 syntax.AttributeLists,
                 location,
@@ -448,7 +448,7 @@ private TypeWithAnnotations ComputeType(Binder binder, SyntaxNode syntax, Bindin
             var typeSyntax = GetTypeSyntax(syntax);
             Debug.Assert(typeSyntax is not ScopedTypeSyntax);
 
-            typeSyntax = typeSyntax.SkipScoped(out _).SkipRef(out _);
+            typeSyntax = typeSyntax.SkipScoped(out _).SkipRef();
             var type = binder.BindType(typeSyntax, diagnostics);
             CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);
 
@@ -560,7 +560,7 @@ protected override bool HasPointerTypeSyntactically
             {
                 var typeSyntax = GetTypeSyntax(CSharpSyntaxNode);
                 Debug.Assert(typeSyntax is not ScopedTypeSyntax);
-                typeSyntax = typeSyntax.SkipScoped(out _).SkipRef(out _);
+                typeSyntax = typeSyntax.SkipScoped(out _).SkipRef();
                 return typeSyntax.Kind() switch { SyntaxKind.PointerType => true, SyntaxKind.FunctionPointerType => true, _ => false };
             }
         }

@@ -449,7 +449,7 @@ internal static bool IsIdentifierVarOrPredefinedType(this Syntax.InternalSyntax.
         internal static bool IsDeclarationExpressionType(SyntaxNode node, [NotNullWhen(true)] out DeclarationExpressionSyntax? parent)
         {
             parent = node.ModifyingScopedOrRefTypeOrSelf().Parent as DeclarationExpressionSyntax;
-            return node == parent?.Type.SkipScoped(out _).SkipRef(out _);
+            return node == parent?.Type.SkipScoped(out _).SkipRef();
         }
 
         /// <summary>