Support 'scoped' modifier for parameters and locals

src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs

@@ -48,6 +48,7 @@ public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnno
             public override bool IsAsync { get { return false; } }
             public override bool IsStatic => false;
             public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }
+            public override DeclarationScope Scope(int index) => DeclarationScope.Unscoped;
             public override MessageID MessageID { get { return MessageID.IDS_FeatureQueryExpression; } } // TODO: what is the correct ID here?
             public override Location ParameterLocation(int index) { return _parameters[index].Locations[0]; }
             public override TypeWithAnnotations ParameterTypeWithAnnotations(int index) { throw new ArgumentException(); } // implicitly typed

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

@@ -2814,6 +2814,7 @@ private BoundExpression BindOutVariableDeclarationArgument(
                     CheckFeatureAvailability(declarationExpression, MessageID.IDS_FeatureExpressionVariablesInQueriesAndInitializers, diagnostics);
                 }
 
+                // PROTOTYPE: Test with 'out scoped R' and 'out scoped var', with -langversion:10 and -langversion:11.
                 bool isConst = false;
                 AliasSymbol alias;
                 var declType = BindVariableTypeWithAnnotations(declarationExpression, diagnostics, typeSyntax, ref isConst, out isVar, out alias);
@@ -7105,7 +7106,7 @@ protected BoundExpression BindFieldAccess(
             // If this is a ref field from another compilation, check for support for ref fields.
             // No need to check for a reference to a field declared in this compilation since
             // we check at the declaration site. (Check RefKind after checking compilation to
-            // avoid cycles for source symbols.
+            // avoid cycles for source symbols.)
             if ((object)Compilation.SourceModule != fieldSymbol.OriginalDefinition.ContainingModule &&
                 fieldSymbol.RefKind != RefKind.None)
             {

src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs

@@ -40,6 +40,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             ImmutableArray<string> names = default;
             ImmutableArray<RefKind> refKinds = default;
+            ImmutableArray<DeclarationScope> scopes = default;
             ImmutableArray<bool> nullCheckedOpt = default;
             ImmutableArray<TypeWithAnnotations> types = default;
             RefKind returnRefKind = RefKind.None;
@@ -99,10 +100,10 @@ private UnboundLambda AnalyzeAnonymousFunction(
             if (parameterSyntaxList != null)
             {
                 var hasExplicitlyTypedParameterList = true;
-                var allValue = true;
 
                 var typesBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance();
                 var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance();
+                var scopesBuilder = ArrayBuilder<DeclarationScope>.GetInstance();
                 var nullCheckedBuilder = ArrayBuilder<bool>.GetInstance();
                 var attributesBuilder = ArrayBuilder<SyntaxList<AttributeListSyntax>>.GetInstance();
 
@@ -138,31 +139,31 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     var typeSyntax = p.Type;
                     TypeWithAnnotations type = default;
                     var refKind = RefKind.None;
+                    var scope = DeclarationScope.Unscoped;
 
                     if (typeSyntax == null)
                     {
                         hasExplicitlyTypedParameterList = false;
                     }
                     else
                     {
+                        bool scopedBeforeRef = false;
+                        bool scopedAfterRef = false;
                         type = BindType(typeSyntax, diagnostics);
                         foreach (var modifier in p.Modifiers)
                         {
                             switch (modifier.Kind())
                             {
                                 case SyntaxKind.RefKeyword:
                                     refKind = RefKind.Ref;
-                                    allValue = false;
                                     break;
 
                                 case SyntaxKind.OutKeyword:
                                     refKind = RefKind.Out;
-                                    allValue = false;
                                     break;
 
                                 case SyntaxKind.InKeyword:
                                     refKind = RefKind.In;
-                                    allValue = false;
                                     break;
 
                                 case SyntaxKind.ParamsKeyword:
@@ -175,13 +176,34 @@ private UnboundLambda AnalyzeAnonymousFunction(
                                 case SyntaxKind.ThisKeyword:
                                     Error(diagnostics, ErrorCode.ERR_ThisInBadContext, modifier);
                                     break;
+
+                                case SyntaxKind.ScopedKeyword:
+                                    ModifierUtils.CheckScopedModifierAvailability(p, modifier, diagnostics);
+                                    if (refKind == RefKind.None)
+                                    {
+                                        scopedBeforeRef = true;
+                                    }
+                                    else
+                                    {
+                                        scopedAfterRef = true;
+                                    }
+                                    break;
                             }
                         }
+                        if (scopedAfterRef)
+                        {
+                            scope = DeclarationScope.ValueScoped;
+                        }
+                        else if (scopedBeforeRef)
+                        {
+                            scope = (refKind == RefKind.None) ? DeclarationScope.ValueScoped : DeclarationScope.RefScoped;
+                        }
                     }
 
                     namesBuilder.Add(p.Identifier.ValueText);
                     typesBuilder.Add(type);
                     refKindsBuilder.Add(refKind);
+                    scopesBuilder.Add(scope);
                     nullCheckedBuilder.Add(isNullChecked(p));
                     attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default);
                 }
@@ -193,11 +215,16 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     types = typesBuilder.ToImmutable();
                 }
 
-                if (!allValue)
+                if (refKindsBuilder.Any(r => r != RefKind.None))
                 {
                     refKinds = refKindsBuilder.ToImmutable();
                 }
 
+                if (scopesBuilder.Any(s => s != DeclarationScope.Unscoped))
+                {
+                    scopes = scopesBuilder.ToImmutable();
+                }
+
                 if (nullCheckedBuilder.Contains(true))
                 {
                     nullCheckedOpt = nullCheckedBuilder.ToImmutable();
@@ -209,6 +236,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
                 }
 
                 typesBuilder.Free();
+                scopesBuilder.Free();
                 refKindsBuilder.Free();
                 nullCheckedBuilder.Free();
                 attributesBuilder.Free();
@@ -221,7 +249,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             namesBuilder.Free();
 
-            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, nullCheckedOpt, isAsync, isStatic);
+            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, scopes, types, names, discardsOpt, nullCheckedOpt, isAsync, isStatic);
 
             static bool isNullChecked(ParameterSyntax parameter)
                 => parameter.ExclamationExclamationToken.IsKind(SyntaxKind.ExclamationExclamationToken);
@@ -322,10 +350,17 @@ private UnboundLambda BindAnonymousFunction(AnonymousFunctionExpressionSyntax sy
                 for (int i = 0; i < lambda.ParameterCount; i++)
                 {
                     // UNDONE: Where do we report improper use of pointer types?
-                    var type = lambda.Data.ParameterTypeWithAnnotations(i);
-                    if (type.HasType && type.IsStatic)
+                    var type = data.ParameterTypeWithAnnotations(i).Type;
+                    if (type is { })
                     {
-                        Error(diagnostics, ErrorFacts.GetStaticClassParameterCode(useWarning: false), syntax, type.Type);
+                        if (type.IsStatic)
+                        {
+                            Error(diagnostics, ErrorFacts.GetStaticClassParameterCode(useWarning: false), syntax, type);
+                        }
+                        if (data.Scope(i) == DeclarationScope.ValueScoped && !type.IsValidScopedType())
+                        {
+                            diagnostics.Add(ErrorCode.ERR_ScopedRefAndRefStructOnly, data.ParameterLocation(i));
+                        }
                     }
                 }
             }

src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs

@@ -694,6 +694,22 @@ private BoundStatement BindDeclarationStatementParts(LocalDeclarationStatementSy
             var typeSyntax = node.Declaration.Type.SkipRef(out _);
             bool isConst = node.IsConst;
 
+            foreach (var modifier in node.Modifiers)
+            {
+                // Check for support for 'scoped'. Duplicate modifiers are reported
+                // as errors in parsing rather than here.
+                if (modifier.Kind() == SyntaxKind.ScopedKeyword)
+                {
+                    ModifierUtils.CheckScopedModifierAvailability(node, modifier, diagnostics);
+                }
+            }
+
+            if (node.Declaration.Type is RefTypeSyntax { ScopedKeyword: var scopedKeyword } &&
+                scopedKeyword.Kind() == SyntaxKind.ScopedKeyword)
+            {
+                ModifierUtils.CheckScopedModifierAvailability(typeSyntax, scopedKeyword, diagnostics);
+            }
+
             bool isVar;
             AliasSymbol alias;
             TypeWithAnnotations declType = BindVariableTypeWithAnnotations(node.Declaration, diagnostics, typeSyntax, ref isConst, isVar: out isVar, alias: out alias);
@@ -1078,6 +1094,11 @@ protected BoundLocalDeclaration BindVariableDeclaration(
                 hasErrors = true;
             }
 
+            if (localSymbol.Scope == DeclarationScope.ValueScoped && !declTypeOpt.Type.IsValidScopedType())
+            {
+                localDiagnostics.Add(ErrorCode.ERR_ScopedRefAndRefStructOnly, typeSyntax.Location);
+            }
+
             localSymbol.SetTypeWithAnnotations(declTypeOpt);
 
             if (initializerOpt != null)

src/Compilers/CSharp/Portable/Binder/LocalScopeBinder.cs

@@ -241,9 +241,10 @@ internal void BuildLocals(Binder enclosingBinder, StatementSyntax statement, Arr
                         {
                             kind = LocalDeclarationKind.RegularVariable;
                         }
+                        bool scopedModifier = decl.Modifiers.Any(SyntaxKind.ScopedKeyword);
                         foreach (var vdecl in decl.Declaration.Variables)
                         {
-                            var localSymbol = MakeLocal(decl.Declaration, vdecl, kind, localDeclarationBinder);
+                            var localSymbol = MakeLocal(decl.Declaration, vdecl, kind, localDeclarationBinder, scopedModifier);
                             locals.Add(localSymbol);
 
                             // also gather expression-declared variables from the bracketed argument lists and the initializers
@@ -313,7 +314,7 @@ internal void BuildLocalFunctions(StatementSyntax statement, ref ArrayBuilder<Lo
             }
         }
 
-        protected SourceLocalSymbol MakeLocal(VariableDeclarationSyntax declaration, VariableDeclaratorSyntax declarator, LocalDeclarationKind kind, Binder initializerBinderOpt = null)
+        protected SourceLocalSymbol MakeLocal(VariableDeclarationSyntax declaration, VariableDeclaratorSyntax declarator, LocalDeclarationKind kind, Binder initializerBinderOpt = null, bool scopedModifier = false)
         {
             return SourceLocalSymbol.MakeLocal(
                 this.ContainingMemberOrLambda,
@@ -323,7 +324,8 @@ protected SourceLocalSymbol MakeLocal(VariableDeclarationSyntax declaration, Var
                 declarator.Identifier,
                 kind,
                 declarator.Initializer,
-                initializerBinderOpt);
+                initializerBinderOpt,
+                scopedModifier);
         }
 
         protected LocalFunctionSymbol MakeLocalFunction(LocalFunctionStatementSyntax declaration)

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -380,6 +380,7 @@ public static UnboundLambda Create(
             TypeWithAnnotations returnType,
             ImmutableArray<SyntaxList<AttributeListSyntax>> parameterAttributes,
             ImmutableArray<RefKind> refKinds,
+            ImmutableArray<DeclarationScope> scopes,
             ImmutableArray<TypeWithAnnotations> types,
             ImmutableArray<string> names,
             ImmutableArray<bool> discardsOpt,
@@ -392,7 +393,7 @@ public static UnboundLambda Create(
             bool hasErrors = !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType);
 
             var functionType = FunctionTypeSymbol.CreateIfFeatureEnabled(syntax, binder, static (binder, expr) => ((UnboundLambda)expr).Data.InferDelegateType());
-            var data = new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, nullCheckedOpt, types, refKinds, isAsync, isStatic, includeCache: true);
+            var data = new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, nullCheckedOpt, types, refKinds, scopes, isAsync, isStatic, includeCache: true);
             var lambda = new UnboundLambda(syntax, data, functionType, withDependencies, hasErrors: hasErrors);
             data.SetUnboundLambda(lambda);
             functionType?.SetExpression(lambda.WithNoCache());
@@ -449,6 +450,7 @@ public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTyp
             => BindForReturnTypeInference(delegateType).GetInferredReturnType(conversions, _nullableState, ref useSiteInfo, out inferredFromFunctionType);
 
         public RefKind RefKind(int index) { return Data.RefKind(index); }
+        public DeclarationScope Scope(int index) { return Data.Scope(index); }
         public void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diagnostics, TypeSymbol targetType) { Data.GenerateAnonymousFunctionConversionError(diagnostics, targetType); }
         public bool GenerateSummaryErrors(BindingDiagnosticBag diagnostics) { return Data.GenerateSummaryErrors(diagnostics); }
         public bool IsAsync { get { return Data.IsAsync; } }
@@ -530,6 +532,7 @@ internal UnboundLambdaState WithCaching(bool includeCache)
         public abstract Location ParameterLocation(int index);
         public abstract TypeWithAnnotations ParameterTypeWithAnnotations(int index);
         public abstract RefKind RefKind(int index);
+        public abstract DeclarationScope Scope(int index);
         protected abstract BoundBlock BindLambdaBody(LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, BindingDiagnosticBag diagnostics);
 
         /// <summary>
@@ -734,6 +737,7 @@ private BoundLambda ReallyBind(NamedTypeSymbol delegateType, bool inExpressionTr
             }
 
             ParameterHelpers.EnsureNativeIntegerAttributeExists(compilation, lambdaParameters, diagnostics, modifyCompilation: false);
+            ParameterHelpers.EnsureLifetimeAnnotationAttributeExists(compilation, lambdaParameters, diagnostics, modifyCompilation: false);
             ParameterHelpers.EnsureNullableAttributeExists(compilation, lambdaSymbol, lambdaParameters, diagnostics, modifyCompilation: false);
             // Note: we don't need to warn on annotations used in #nullable disable context for lambdas, as this is handled in binding already
 
@@ -1326,6 +1330,7 @@ internal sealed class PlainUnboundLambdaState : UnboundLambdaState
         private readonly ImmutableArray<bool> _parameterIsNullCheckedOpt;
         private readonly ImmutableArray<TypeWithAnnotations> _parameterTypesWithAnnotations;
         private readonly ImmutableArray<RefKind> _parameterRefKinds;
+        private readonly ImmutableArray<DeclarationScope> _parameterScopes;
         private readonly bool _isAsync;
         private readonly bool _isStatic;
 
@@ -1339,6 +1344,7 @@ internal PlainUnboundLambdaState(
             ImmutableArray<bool> parameterIsNullCheckedOpt,
             ImmutableArray<TypeWithAnnotations> parameterTypesWithAnnotations,
             ImmutableArray<RefKind> parameterRefKinds,
+            ImmutableArray<DeclarationScope> parameterScopes,
             bool isAsync,
             bool isStatic,
             bool includeCache)
@@ -1352,11 +1358,11 @@ internal PlainUnboundLambdaState(
             _parameterIsNullCheckedOpt = parameterIsNullCheckedOpt;
             _parameterTypesWithAnnotations = parameterTypesWithAnnotations;
             _parameterRefKinds = parameterRefKinds;
+            _parameterScopes = parameterScopes;
             _isAsync = isAsync;
             _isStatic = isStatic;
         }
 
-
         public override bool HasSignature { get { return !_parameterNames.IsDefault; } }
 
         public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
@@ -1429,6 +1435,12 @@ public override RefKind RefKind(int index)
             return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index];
         }
 
+        public override DeclarationScope Scope(int index)
+        {
+            Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);
+            return _parameterScopes.IsDefault ? DeclarationScope.Unscoped : _parameterScopes[index];
+        }
+
         public override TypeWithAnnotations ParameterTypeWithAnnotations(int index)
         {
             Debug.Assert(this.HasExplicitlyTypedParameterList);
@@ -1438,7 +1450,7 @@ public override TypeWithAnnotations ParameterTypeWithAnnotations(int index)
 
         protected override UnboundLambdaState WithCachingCore(bool includeCache)
         {
-            return new PlainUnboundLambdaState(Binder, _returnRefKind, _returnType, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterIsNullCheckedOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _isAsync, _isStatic, includeCache);
+            return new PlainUnboundLambdaState(Binder, _returnRefKind, _returnType, _parameterAttributes, _parameterNames, _parameterIsDiscardOpt, _parameterIsNullCheckedOpt, _parameterTypesWithAnnotations, _parameterRefKinds, _parameterScopes, _isAsync, _isStatic, includeCache);
         }
 
         protected override BoundExpression? GetLambdaExpressionBody(BoundBlock body)

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6775,6 +6775,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_ListPatternRequiresLength" xml:space="preserve">
     <value>List patterns may not be used for a value of type '{0}'. No suitable 'Length' or 'Count' property was found.</value>
   </data>
+  <data name="ERR_ScopedRefAndRefStructOnly" xml:space="preserve">
+    <value>The 'scoped' modifier can be used for refs and ref struct values only.</value>
+  </data>
 
   <data name="WRN_UseDefViolationPropertySupportedVersion" xml:space="preserve">
     <value>Auto-implemented property '{0}' is read before being explicitly assigned, causing a preceding implicit assignment of 'default'.</value>

src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs

@@ -2267,5 +2267,7 @@ public override RefKind RefKind
         /// Checking escape scopes is not valid here.
         /// </summary>
         internal override uint RefEscapeScope => throw ExceptionUtilities.Unreachable;
+
+        internal override DeclarationScope Scope => DeclarationScope.Unscoped;
     }
 }