Merge pull request #39012 from dotnet/merges/master-to-features/local-function-attributes

Merge master to features/local-function-attributes

Author: RikkiGibson

docs/compilers/CSharp/Compiler Breaking Changes - post VS2019.md

@@ -80,3 +80,4 @@ In Visual Studio version 16.4, the nullable analysis will be more stringent for
     class C<T> where T : I<(int a, int b)>, I<(int c, int d)> { } // error
     ```
 
+12. Previously, the language version was not checked for `this ref` and `this in` orderings of parameter modifiers. In *Visual Studio 2019 version 16.4* these orderings produce an error with langversion below 7.2. See https://github.com/dotnet/roslyn/issues/38486

eng/Version.Details.xml

@@ -3,9 +3,9 @@
   <ProductDependencies>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="5.0.0-beta.19480.3">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="5.0.0-beta.19501.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>238f1bbb23ba67616818d0b242c5b55a18edec55</Sha>
+      <Sha>c21a409f11386d22c6083198176868d3974de832</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>

eng/common/tools.sh

@@ -332,7 +332,7 @@ function MSBuild {
     # Work around issues with Azure Artifacts credential provider
     # https://github.com/dotnet/arcade/issues/3932
     if [[ "$ci" == true ]]; then
-      dotnet nuget locals http-cache -c
+      "$_InitializeBuildTool" nuget locals http-cache -c
 
       export NUGET_PLUGIN_HANDSHAKE_TIMEOUT_IN_SECONDS=20
       export NUGET_PLUGIN_REQUEST_TIMEOUT_IN_SECONDS=20

eng/docker/Mono/Dockerfile

@@ -3,6 +3,16 @@
 # Licensed under the MIT license. See LICENSE file in the project root for full license information.
 #
 
+FROM ubuntu:16.04 as Info
+
+# install wget
+RUN apt-get update && \
+    apt-get install -y wget
+
+# we always want to download the content of the release file, regardless of cache
+ARG CACHE_BUST=0 
+RUN wget https://download.mono-project.com/repo/ubuntu/dists/nightly-xenial/Release
+
 FROM ubuntu:16.04
 
 # Install the base toolchain we need to build anything
@@ -41,9 +51,10 @@ RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E03280
     apt-get clean
 
 
+# Copy will check the hash of the release file. If it's changed it will be copied and everything from this point will re-run regardless of cache status
+COPY --from=Info /Release .
+
 # Update previously installed mono-devel.
-# Cache bust ensures we'll always run the commands following regardless of docker cache status
-ARG CACHE_BUST=0
 RUN apt-get update && apt-get upgrade -y
 
 # Setup User to match Host User, and give superuser permissions
@@ -60,4 +71,4 @@ RUN chmod -R 755 /usr/lib/sudo
 USER ${USER_ID}
 
 # Set working directory
-WORKDIR /opt/code
+WORKDIR /opt/code

global.json

@@ -7,6 +7,6 @@
     "xcopy-msbuild": "16.3.0-alpha"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "5.0.0-beta.19480.3"
+    "Microsoft.DotNet.Arcade.Sdk": "5.0.0-beta.19501.4"
   }
 }

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

@@ -82,7 +82,7 @@ private BoundExpression SelectField(SimpleNameSyntax node, BoundExpression recei
                         node,
                         LookupResultKind.Empty,
                         ImmutableArray.Create<Symbol>(receiver.ExpressionSymbol),
-                        ImmutableArray.Create(receiver),
+                        ImmutableArray.Create(BindToTypeForErrorRecovery(receiver)),
                         new ExtendedErrorTypeSymbol(this.Compilation, "", 0, info));
                 }
 

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

@@ -53,7 +53,8 @@ protected BoundExpression CreateConversion(
             ConversionGroup conversionGroupOpt,
             bool wasCompilerGenerated,
             TypeSymbol destination,
-            DiagnosticBag diagnostics)
+            DiagnosticBag diagnostics,
+            bool hasErrors = false)
         {
             Debug.Assert(source != null);
             Debug.Assert((object)destination != null);
@@ -109,7 +110,6 @@ protected BoundExpression CreateConversion(
             if (source.Kind == BoundKind.UnconvertedSwitchExpression)
             {
                 TypeSymbol type = source.Type;
-                bool hasErrors = false;
                 if (type is null)
                 {
                     Debug.Assert(!conversion.Exists);
@@ -128,7 +128,7 @@ protected BoundExpression CreateConversion(
             {
                 // User-defined conversions are likely to be represented as multiple
                 // BoundConversion instances so a ConversionGroup is necessary.
-                return CreateUserDefinedConversion(syntax, source, conversion, isCast: isCast, conversionGroupOpt ?? new ConversionGroup(conversion), destination, diagnostics);
+                return CreateUserDefinedConversion(syntax, source, conversion, isCast: isCast, conversionGroupOpt ?? new ConversionGroup(conversion), destination, diagnostics, hasErrors);
             }
 
             ConstantValue constantValue = this.FoldConstantConversion(syntax, source, conversion, destination, diagnostics);
@@ -146,7 +146,8 @@ protected BoundExpression CreateConversion(
                 explicitCastInCode: isCast && !wasCompilerGenerated,
                 conversionGroupOpt,
                 constantValueOpt: constantValue,
-                type: destination)
+                type: destination,
+                hasErrors: hasErrors)
             { WasCompilerGenerated = wasCompilerGenerated };
         }
 
@@ -172,13 +173,22 @@ private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression
                 source.DefaultLabel, source.ReportedNotExhaustive, destination, hasErrors || source.HasErrors);
         }
 
-        private BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup conversionGroup, TypeSymbol destination, DiagnosticBag diagnostics)
+        private BoundExpression CreateUserDefinedConversion(
+            SyntaxNode syntax,
+            BoundExpression source,
+            Conversion conversion,
+            bool isCast,
+            ConversionGroup conversionGroup,
+            TypeSymbol destination,
+            DiagnosticBag diagnostics,
+            bool hasErrors)
         {
             Debug.Assert(conversionGroup != null);
 
             if (!conversion.IsValid)
             {
-                GenerateImplicitConversionError(diagnostics, syntax, conversion, source, destination);
+                if (!hasErrors)
+                    GenerateImplicitConversionError(diagnostics, syntax, conversion, source, destination);
 
                 return new BoundConversion(
                     syntax,
@@ -226,7 +236,7 @@ private BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpr
                 source: source,
                 conversion: conversion.UserDefinedFromConversion,
                 isCast: false,
-                conversionGroup,
+                conversionGroupOpt: conversionGroup,
                 wasCompilerGenerated: false,
                 destination: conversion.BestUserDefinedConversionAnalysis.FromType,
                 diagnostics: diagnostics);
@@ -243,7 +253,7 @@ private BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpr
                     source: convertedOperand,
                     conversion: Conversions.ClassifyStandardConversion(null, convertedOperand.Type, conversionParameterType, ref useSiteDiagnostics),
                     isCast: false,
-                    conversionGroup,
+                    conversionGroupOpt: conversionGroup,
                     wasCompilerGenerated: true,
                     destination: conversionParameterType,
                     diagnostics: diagnostics);
@@ -287,7 +297,7 @@ private BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpr
                         source: userDefinedConversion,
                         conversion: Conversions.ClassifyStandardConversion(null, conversionReturnType, conversionToType, ref useSiteDiagnostics),
                         isCast: false,
-                        conversionGroup,
+                        conversionGroupOpt: conversionGroup,
                         wasCompilerGenerated: true,
                         destination: conversionToType,
                         diagnostics: diagnostics);
@@ -317,7 +327,7 @@ private BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpr
                 source: userDefinedConversion,
                 conversion: toConversion,
                 isCast: false,
-                conversionGroup,
+                conversionGroupOpt: conversionGroup,
                 wasCompilerGenerated: true, // NOTE: doesn't necessarily set flag on resulting bound expression.
                 destination: destination,
                 diagnostics: diagnostics);

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

@@ -167,7 +167,7 @@ private BoundBadExpression BadExpression(SyntaxNode syntax, LookupResultKind res
             return new BoundBadExpression(syntax,
                 resultKind,
                 symbols,
-                childNodes,
+                childNodes.SelectAsArray((e, self) => self.BindToTypeForErrorRecovery(e), this),
                 CreateErrorType());
         }
 
@@ -207,7 +207,7 @@ private BoundExpression ToBadExpression(BoundExpression expr, LookupResultKind r
                     expr.Syntax,
                     resultKind,
                     symbols.ToImmutableAndFree(),
-                    ImmutableArray.Create(expr),
+                    ImmutableArray.Create(BindToTypeForErrorRecovery(expr)),
                     resultType ?? CreateErrorType());
             }
         }
@@ -234,6 +234,19 @@ internal BoundExpression BindRValueWithoutTargetType(ExpressionSyntax node, Diag
             return BindToNaturalType(BindValue(node, diagnostics, BindValueKind.RValue), diagnostics, reportDefaultMissingType);
         }
 
+        internal BoundExpression BindToTypeForErrorRecovery(BoundExpression expression, TypeSymbol type = null)
+        {
+            if (expression is null)
+                return null;
+            var discardedDiagnostics = DiagnosticBag.GetInstance();
+            var result =
+                (!expression.NeedsToBeConverted() || expression.WasConverted) ? expression :
+                type is null ? BindToNaturalType(expression, discardedDiagnostics) :
+                GenerateConversionForAssignment(type, expression, discardedDiagnostics);
+            discardedDiagnostics.Free();
+            return result;
+        }
+
         /// <summary>
         /// Bind an rvalue expression to its natural type.  For example, a switch expression that has not been
         /// converted to another type has to be converted to its own natural type by applying a conversion to
@@ -651,7 +664,7 @@ private BoundExpression BindExpressionInternal(ExpressionSyntax node, Diagnostic
                     return BindRefExpression(node, diagnostics);
 
                 case SyntaxKind.DeclarationExpression:
-                    return BindDeclarationExpression((DeclarationExpressionSyntax)node, diagnostics);
+                    return BindDeclarationExpressionAsError((DeclarationExpressionSyntax)node, diagnostics);
 
                 case SyntaxKind.SuppressNullableWarningExpression:
                     return BindSuppressNullableWarningExpression((PostfixUnaryExpressionSyntax)node, diagnostics);
@@ -735,7 +748,7 @@ private static bool IsThrowExpressionInProperContext(ThrowExpressionSyntax node)
         }
 
         // Bind a declaration expression where it isn't permitted.
-        private BoundExpression BindDeclarationExpression(DeclarationExpressionSyntax node, DiagnosticBag diagnostics)
+        private BoundExpression BindDeclarationExpressionAsError(DeclarationExpressionSyntax node, DiagnosticBag diagnostics)
         {
             // This is an error, as declaration expressions are handled specially in every context in which
             // they are permitted. So we have a context in which they are *not* permitted. Nevertheless, we
@@ -746,13 +759,13 @@ private BoundExpression BindDeclarationExpression(DeclarationExpressionSyntax no
             AliasSymbol alias;
             var declType = BindVariableTypeWithAnnotations(node.Designation, diagnostics, node.Type, ref isConst, out isVar, out alias);
             Error(diagnostics, ErrorCode.ERR_DeclarationExpressionNotPermitted, node);
-            return BindDeclarationVariables(declType, node.Designation, node, diagnostics);
+            return BindDeclarationVariablesForErrorRecovery(declType, node.Designation, node, diagnostics);
         }
 
         /// <summary>
         /// Bind a declaration variable where it isn't permitted. The caller is expected to produce a diagnostic.
         /// </summary>
-        private BoundExpression BindDeclarationVariables(TypeWithAnnotations declTypeWithAnnotations, VariableDesignationSyntax node, CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
+        private BoundExpression BindDeclarationVariablesForErrorRecovery(TypeWithAnnotations declTypeWithAnnotations, VariableDesignationSyntax node, CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
         {
             declTypeWithAnnotations = declTypeWithAnnotations.HasType ? declTypeWithAnnotations : TypeWithAnnotations.Create(CreateErrorType("var"));
             switch (node.Kind())
@@ -761,7 +774,7 @@ private BoundExpression BindDeclarationVariables(TypeWithAnnotations declTypeWit
                     {
                         var single = (SingleVariableDesignationSyntax)node;
                         var result = BindDeconstructionVariable(declTypeWithAnnotations, single, syntax, diagnostics);
-                        return result;
+                        return BindToTypeForErrorRecovery(result);
                     }
                 case SyntaxKind.DiscardDesignation:
                     {
@@ -776,7 +789,7 @@ private BoundExpression BindDeclarationVariables(TypeWithAnnotations declTypeWit
 
                         foreach (var n in tuple.Variables)
                         {
-                            builder.Add(BindDeclarationVariables(declTypeWithAnnotations, n, n, diagnostics));
+                            builder.Add(BindDeclarationVariablesForErrorRecovery(declTypeWithAnnotations, n, n, diagnostics));
                             namesBuilder.Add(InferTupleElementName(n));
                         }
                         ImmutableArray<BoundExpression> subExpressions = builder.ToImmutableAndFree();
@@ -1364,7 +1377,7 @@ private BoundExpression BindIdentifier(
                             syntax: node,
                             resultKind: LookupResultKind.WrongArity,
                             symbols: ImmutableArray.Create(symbol),
-                            childBoundNodes: ImmutableArray.Create(expression),
+                            childBoundNodes: ImmutableArray.Create(BindToTypeForErrorRecovery(expression)),
                             type: expression.Type,
                             hasErrors: isError);
                     }
@@ -2150,23 +2163,14 @@ private BoundExpression BindCastCore(ExpressionSyntax node, BoundExpression oper
             diagnostics.Add(node, useSiteDiagnostics);
 
             var conversionGroup = new ConversionGroup(conversion, targetTypeWithAnnotations);
-            if (operand.HasAnyErrors || targetType.IsErrorType() || !conversion.IsValid || targetType.IsStatic)
+            bool suppressErrors = operand.HasAnyErrors || targetType.IsErrorType();
+            bool hasErrors = !conversion.IsValid || targetType.IsStatic;
+            if (hasErrors && !suppressErrors)
             {
                 GenerateExplicitConversionErrors(diagnostics, node, conversion, operand, targetType);
-
-                return new BoundConversion(
-                    node,
-                    operand,
-                    conversion,
-                    @checked: CheckOverflowAtRuntime,
-                    explicitCastInCode: true,
-                    conversionGroup,
-                    constantValueOpt: ConstantValue.NotAvailable,
-                    type: targetType,
-                    hasErrors: true);
             }
 
-            return CreateConversion(node, operand, conversion, isCast: true, conversionGroup, wasCompilerGenerated: wasCompilerGenerated, destination: targetType, diagnostics: diagnostics);
+            return CreateConversion(node, operand, conversion, isCast: true, conversionGroupOpt: conversionGroup, wasCompilerGenerated: wasCompilerGenerated, destination: targetType, diagnostics: diagnostics, hasErrors: hasErrors | suppressErrors);
         }
 
         private void GenerateExplicitConversionErrors(
@@ -6155,7 +6159,7 @@ private BoundExpression BindMemberAccessBadResult(
                 node,
                 lookupKind,
                 (object)symbolOpt == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(symbolOpt),
-                boundLeft == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(boundLeft),
+                boundLeft == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(BindToTypeForErrorRecovery(boundLeft)),
                 GetNonMethodMemberType(symbolOpt));
         }
 
@@ -7036,7 +7040,9 @@ private BoundExpression BindArrayAccess(ExpressionSyntax node, BoundExpression e
                 ? arrayType
                 : arrayType.ElementType;
 
-            return new BoundArrayAccess(node, expr, convertedArguments.AsImmutableOrNull(), resultType, hasErrors);
+            return hasErrors
+                ? new BoundArrayAccess(node, BindToTypeForErrorRecovery(expr), convertedArguments.Select(e => BindToTypeForErrorRecovery(e)).AsImmutableOrNull(), resultType, hasErrors: true)
+                : new BoundArrayAccess(node, expr, convertedArguments.AsImmutableOrNull(), resultType, hasErrors: false);
         }
 
         private BoundExpression ConvertToArrayIndex(BoundExpression index, SyntaxNode node, DiagnosticBag diagnostics, bool allowIndexAndRange)