Package: guix-patches;
Reported by: unmush <unmush <at> proton.me>
Date: Fri, 29 Nov 2024 17:46:03 UTC
Severity: normal
Tags: patch
Merged with 57625
Done: Efraim Flashner <efraim <at> flashner.co.il>
Bug is archived. No further changes may be made.
View this message in rfc822 format
From: Efraim Flashner <efraim <at> flashner.co.il> To: 74609 <at> debbugs.gnu.org Cc: aaron.covrig.us <at> ieee.org, ludo <at> gnu.org, unmush <unmush <at> hashbang.sh>, richard <at> freakingpenguin.com, unmush <at> proton.me, janneke <at> gnu.org Subject: [bug#74609] [PATCH 15/21] gnu: Add mono-5.4.0. Date: Mon, 16 Dec 2024 19:26:38 +0200
From: unmush <unmush <at> hashbang.sh>
* gnu/packages/dotnet.scm
(mono-5.4.0-external-repo-specs, mono-5.4.0): New variables.
* gnu/packages/patches/corefx-mono-5.4.0-patches.patch: New patch.
* gnu/packages/patches/mono-5.4.0-patches.patch: New patch.
* gnu/local.mk (dist_patch_DATA): Register new patches.
Change-Id: I1510c8ac13db60e5beab8033be3efc483e984ec0
---
gnu/local.mk | 2 +
gnu/packages/dotnet.scm | 92 ++
.../patches/corefx-mono-5.4.0-patches.patch | 915 ++++++++++++++++++
gnu/packages/patches/mono-5.4.0-patches.patch | 100 ++
4 files changed, 1109 insertions(+)
create mode 100644 gnu/packages/patches/corefx-mono-5.4.0-patches.patch
create mode 100644 gnu/packages/patches/mono-5.4.0-patches.patch
diff --git a/gnu/local.mk b/gnu/local.mk
index 5facc66932b..aa129d89d58 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -1114,6 +1114,7 @@ dist_patch_DATA = \
%D%/packages/patches/converseen-hide-non-free-pointers.patch \
%D%/packages/patches/cool-retro-term-wctype.patch \
%D%/packages/patches/coq-autosubst-1.8-remove-deprecated-files.patch \
+ %D%/packages/patches/corefx-mono-5.4.0-patches.patch \
%D%/packages/patches/coreutils-gnulib-tests.patch \
%D%/packages/patches/cppcheck-disable-char-signedness-test.patch \
%D%/packages/patches/cppdap-add-CPPDAP_USE_EXTERNAL_GTEST_PACKAGE.patch\
@@ -1825,6 +1826,7 @@ dist_patch_DATA = \
%D%/packages/patches/mono-2.6.4-fixes.patch \
%D%/packages/patches/mono-2.11.4-fixes.patch \
%D%/packages/patches/mono-4.9.0-fix-runtimemetadataversion.patch \
+ %D%/packages/patches/mono-5.4.0-patches.patch \
%D%/packages/patches/mosaicatcher-unbundle-htslib.patch \
%D%/packages/patches/mrrescue-support-love-11.patch \
%D%/packages/patches/mtools-mformat-uninitialized.patch \
diff --git a/gnu/packages/dotnet.scm b/gnu/packages/dotnet.scm
index cf391ed9200..b4355b048e2 100644
--- a/gnu/packages/dotnet.scm
+++ b/gnu/packages/dotnet.scm
@@ -1104,3 +1104,95 @@ (define-public mono-5.2.0
#$@prepare-mono-source-0))))
(native-inputs (modify-inputs (package-native-inputs mono-5.1.0)
(replace "mono" mono-5.1.0)))))
+
+(define mono-5.4.0-external-repo-specs
+ '(("aspnetwebstack" "e77b12e6cc5ed260a98447f609e887337e44e299"
+ "0rks344qr4fmp3fs1264d2qkmm348m8d1kjd7z4l94iiirwn1fq1")
+ ("api-doc-tools" "d03e819838c6241f92f90655cb448cc47c9e8791"
+ "1riki79f3ig3cxigviss81dz601hn92a1gifglm0mzjbs76sf3fj"
+ #:recursive? #t)
+ ("api-snapshot" "b09033be33ab25113743151c644c831158c54042"
+ "0z67iqd1brib6ni36pklrp7rlxyhri5nk3px37fm1aacgrnsk7ck")
+ (("reference-assemblies" "binary-reference-assemblies")
+ "142cbeb62ffabf1dd9c1414d8dd76f93bcbed0c2"
+ "1wkd589hgb16m5zvmp9yb57agyyryaa1jj8vhl4w20i2hp22wad9")
+ ("bockbuild" "0efdb371e6d79abc54c0e3bb3689fa1646f4394e"
+ "10qr1m2wa3zb2i3j16i0cq49higjm451bhlqhqd4rlisqn0w8nrv")
+ ("boringssl" "3e0770e18835714708860ba9fe1af04a932971ff"
+ "139a0gl91a52k2r6na6ialzkqykaj1rk88zjrkaz3sdxx7nmmg6y")
+ ("cecil" "c0eb983dac62519d3ae93a689312076aacecb723"
+ "02i3pwpaf6q00pklfmwxhz0lgp83854dyqnvf4c1ys07cs8y1pdk")
+ (("cecil" "cecil-legacy") "33d50b874fd527118bc361d83de3d494e8bb55e1"
+ "1p4hl1796ib26ykyf5snl6cj0lx0v7mjh0xqhjw6qdh753nsjyhb")
+ ("corefx" "9ad53d674e31327abcc60f35c14387700f50cc68"
+ "0ap4g2fj8wsar4xvbc6dkd2l67qalxlcw5laplq3an5nvj2ld65w"
+ #:patches ("corefx-mono-5.4.0-patches.patch"))
+ ("corert" "48dba73801e804e89f00311da99d873f9c550278"
+ "1zw47jf4cwqmaixylisxi73xf6cap41bwf9vlmpxanzxaqklzsvk")
+ ("ikdasm" "1d7d43603791e0236b56d076578657bee44fef6b"
+ "1kw8ykkad55qhapg6jbvqim7vainqlpz8469flm083lpz7pks3sg")
+ (("ikvm-fork" "ikvm") "847e05fced5c9a41ff0f24f1f9d40d5a8a5772c1"
+ "1fl9bm3lmzf8iqv3x4iqkz9fc54mwdvrxisxg2nvwwcsi4saffpi")
+ ("linker" "99354bf5c13b8055209cb082cddc50c8047ab088"
+ "05zlajnqf83xfvn2whh9nql6j85sq12aw26sqmyqz7zcpml171mj")
+ ("Newtonsoft.Json" "471c3e0803a9f40a0acc8aeceb31de6ff93a52c4"
+ "0dgngd5hqk6yhlg40kabn6qdnknm32zcx9q6bm2w31csnsk5978s")
+ (("NuGet.BuildTasks" "nuget-buildtasks")
+ "b58ba4282377bcefd48abdc2d62ce6330e079abe"
+ "1say03fnqkjsx97zacany3sa5j4mhfk827hkwp23ib02q18f7lvp")
+ (("NUnitLite" "nunit-lite") "690603bea98aae69fca9a65130d88591bc6cabee"
+ "1f845ysjzs3yd9gcyww66dnkx484z5fknb8l0xz74sjmxk2mngwc")
+ ;; ("roslyn-binaries" "1904c7d0682a878e2d25b4d49f3475d12fbb9cc6"
+ ;; "")
+ ("rx" "b29a4b0fda609e0af33ff54ed13652b6ccf0e05e"
+ "1n1jwhmsbkcv2d806immcpzkb72rz04xy98myw355a8w5ah25yiv")
+ ;; ("xunit-binaries" "d4433b0972f40cb3efaa3fbba52869bde5df8fa8"
+ ;; "")
+ ))
+
+(define-public mono-5.4.0
+ (package
+ (inherit mono-5.2.0)
+ (version "5.4.0.212")
+ (name "mono")
+ (source (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://gitlab.winehq.org/mono/mono.git")
+ (commit
+ ;; 5.4.0.135 and before have a bug that makes mono not
+ ;; self-hosting (fails to compile self, example error:
+ ;; System.Data.SqlClient/SqlTransaction.cs(39,22): error
+ ;; CS0738: `System.Data.SqlClient.SqlTransaction' does not
+ ;; implement interface member
+ ;; `System.Data.IDbTransaction.Connection.get' and the best
+ ;; implementing candidate
+ ;; `System.Data.SqlClient.SqlTransaction.Connection.get'
+ ;; return type `System.Data.SqlClient.SqlConnection' does not
+ ;; match interface member return type
+ ;; `System.Data.IDbConnection'
+
+ ;; Note: in above example, SqlConnection implements
+ ;; IDbConnection. My understanding is that for this to
+ ;; compile properly, we need covariant return types, which is
+ ;; a C# 9.0 feature, but somehow the same code has been
+ ;; compiled just fine by previous versions of mono, and is
+ ;; compiled fine by this version, but not specific 5.4.0.XXX
+ ;; versions.
+ "mono-5.4.0.212")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0gx3fxz1wlq5fkj7iphv32vg9m78ia74m9pgn9rab4fyq2k9an2y"))
+ (modules '((guix build utils)
+ (ice-9 string-fun)))
+ (snippet #~(begin
+ #$(add-external-repos
+ mono-5.4.0-external-repo-specs)
+ #$@prepare-mono-source-0))
+ (patches
+ (search-patches
+ "mono-5.4.0-patches.patch"))))
+ (native-inputs (modify-inputs (package-native-inputs mono-5.2.0)
+ (replace "mono" mono-5.2.0)))))
diff --git a/gnu/packages/patches/corefx-mono-5.4.0-patches.patch b/gnu/packages/patches/corefx-mono-5.4.0-patches.patch
new file mode 100644
index 00000000000..034d769ebce
--- /dev/null
+++ b/gnu/packages/patches/corefx-mono-5.4.0-patches.patch
@@ -0,0 +1,915 @@
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/ExpressionTreeCallRewriter.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/ExpressionTreeCallRewriter.cs
+index aa8afa5a1b..3a2518246a 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/ExpressionTreeCallRewriter.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/ExpressionTreeCallRewriter.cs
+@@ -246,8 +246,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+ ExprArrayInit arrinit;
+
+ ExprList list = (ExprList)pExpr.OptionalArguments;
+- if (list.OptionalNextListNode is ExprList next)
++ if (list.OptionalNextListNode is ExprList)
+ {
++ ExprList next = (ExprList)list.OptionalNextListNode;
+ methinfo = (ExprMethodInfo)next.OptionalElement;
+ arrinit = (ExprArrayInit)next.OptionalNextListNode;
+ }
+@@ -382,8 +383,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+ Expr nextNode = list.OptionalNextListNode;
+ ExprPropertyInfo propinfo;
+ ExprArrayInit arguments;
+- if (nextNode is ExprList nextList)
++ if (nextNode is ExprList)
+ {
++ ExprList nextList = (ExprList)list.OptionalNextListNode;
+ propinfo = nextList.OptionalElement as ExprPropertyInfo;
+ arguments = nextList.OptionalNextListNode as ExprArrayInit;
+ }
+@@ -553,8 +555,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+ list = (ExprList)list.OptionalNextListNode;
+ MethodInfo methodInfo;
+ bool bIsLifted = false;
+- if (list.OptionalNextListNode is ExprList next)
++ if (list.OptionalNextListNode is ExprList)
+ {
++ ExprList next = (ExprList)list.OptionalNextListNode;
+ ExprConstant isLifted = (ExprConstant)next.OptionalElement;
+ Debug.Assert(isLifted != null);
+ bIsLifted = isLifted.Val.Int32Val == 1;
+@@ -677,8 +680,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+
+ private Expression GetExpression(Expr pExpr)
+ {
+- if (pExpr is ExprWrap wrap)
++ if (pExpr is ExprWrap)
+ {
++ ExprWrap wrap = (ExprWrap) pExpr;
+ return _DictionaryOfParameters[(ExprCall)wrap.OptionalExpression];
+ }
+ else if (pExpr is ExprConstant)
+@@ -875,20 +879,24 @@ namespace Microsoft.CSharp.RuntimeBinder
+ {
+ for (;;)
+ {
+- if (pExpr is ExprCast cast)
++ if (pExpr is ExprCast)
+ {
++ ExprCast cast = (ExprCast) pExpr;
+ pExpr = cast.Argument;
+ }
+- else if (pExpr is ExprTypeOf typeOf)
++ else if (pExpr is ExprTypeOf)
+ {
++ ExprTypeOf typeOf = (ExprTypeOf) pExpr;
+ return typeOf.SourceType.Type.AssociatedSystemType;
+ }
+- else if (pExpr is ExprMethodInfo methodInfo)
++ else if (pExpr is ExprMethodInfo)
+ {
++ ExprMethodInfo methodInfo = (ExprMethodInfo) pExpr;
+ return GetMethodInfoFromExpr(methodInfo);
+ }
+- else if (pExpr is ExprConstant constant)
++ else if (pExpr is ExprConstant)
+ {
++ ExprConstant constant = (ExprConstant) pExpr;
+ ConstVal val = constant.Val;
+ CType underlyingType = pExpr.Type;
+ object objval;
+@@ -954,8 +962,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+
+ return pExpr.Type.isEnumType() ? Enum.ToObject(pExpr.Type.AssociatedSystemType, objval) : objval;
+ }
+- else if (pExpr is ExprZeroInit zeroInit)
++ else if (pExpr is ExprZeroInit)
+ {
++ ExprZeroInit zeroInit = (ExprZeroInit) pExpr;
+ if ((pExpr = zeroInit.OptionalArgument) == null)
+ {
+ return Activator.CreateInstance(zeroInit.Type.AssociatedSystemType);
+@@ -981,8 +990,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+ Expr p = list;
+ while (list != null)
+ {
+- if (list is ExprList pList)
++ if (list is ExprList)
+ {
++ ExprList pList = (ExprList) list;
+ p = pList.OptionalElement;
+ list = pList.OptionalNextListNode;
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs
+index 6dc888c6ef..89f881f668 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs
+@@ -195,7 +195,8 @@ namespace Microsoft.CSharp.RuntimeBinder
+ LocalVariableSymbol[] locals = PopulateLocalScope(payload, pScope, arguments, parameters);
+
+ // (1.5) - Check to see if we need to defer.
+- if (DeferBinding(payload, arguments, args, locals, out DynamicMetaObject o))
++ DynamicMetaObject o;
++ if (DeferBinding(payload, arguments, args, locals, out o))
+ {
+ deferredBinding = o;
+ return null;
+@@ -1053,8 +1054,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+
+ private static void CheckForConditionalMethodError(Expr pExpr)
+ {
+- if (pExpr is ExprCall call)
++ if (pExpr is ExprCall)
+ {
++ ExprCall call = (ExprCall)pExpr;
+ // This mimics the behavior of the native CompilerSymbolLoader in GetConditionalSymbols. Override
+ // methods cannot have the conditional attribute, but implicitly acquire it from their slot.
+
+@@ -1087,8 +1089,9 @@ namespace Microsoft.CSharp.RuntimeBinder
+ ExprMemberGroup memgroup;
+ TypeArray typeArgs;
+
+- if (pResult is ExprCall call)
++ if (pResult is ExprCall)
+ {
++ ExprCall call = (ExprCall) pResult;
+ type = call.MethWithInst.Ats;
+ methprop = call.MethWithInst.Meth();
+ memgroup = call.MemberGroup;
+@@ -1155,12 +1158,15 @@ namespace Microsoft.CSharp.RuntimeBinder
+
+ private Expr StripNamedArgument(Expr pArg)
+ {
+- if (pArg is ExprNamedArgumentSpecification named)
++ if (pArg is ExprNamedArgumentSpecification)
+ {
++ ExprNamedArgumentSpecification named =
++ (ExprNamedArgumentSpecification) pArg;
+ pArg = named.Value;
+ }
+- else if (pArg is ExprArrayInit init)
++ else if (pArg is ExprArrayInit)
+ {
++ ExprArrayInit init = (ExprArrayInit) pArg;
+ init.OptionalArguments = StripNamedArguments(init.OptionalArguments);
+ }
+
+@@ -1169,14 +1175,16 @@ namespace Microsoft.CSharp.RuntimeBinder
+
+ private Expr StripNamedArguments(Expr pArg)
+ {
+- if (pArg is ExprList list)
++ if (pArg is ExprList)
+ {
++ ExprList list = (ExprList) pArg;
+ for(;;)
+ {
+ list.OptionalElement = StripNamedArgument(list.OptionalElement);
+
+- if (list.OptionalNextListNode is ExprList next)
++ if (list.OptionalNextListNode is ExprList)
+ {
++ ExprList next = (ExprList)list.OptionalNextListNode;
+ list = next;
+ }
+ else
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/Better.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/Better.cs
+index cebfcd94e1..179ac21620 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/Better.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/Better.cs
+@@ -157,8 +157,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // We then go over the specified arguments and put the type for any named argument in the right position in the array.
+ for (int iParam = 0; iParam < args.carg; iParam++)
+ {
+- if (prgexpr[iParam] is ExprNamedArgumentSpecification named)
++ if (prgexpr[iParam] is ExprNamedArgumentSpecification)
+ {
++ ExprNamedArgumentSpecification named = (ExprNamedArgumentSpecification)prgexpr[iParam];
+ // We find the index of the type of the argument in the method parameter list and store that in a temp
+ int index = FindName(methProp.ParameterNames, named.Name);
+ CType tempType = pta[index];
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/ErrorReporting.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/ErrorReporting.cs
+index c406af43de..0ea81ef21c 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/ErrorReporting.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Binding/ErrorReporting.cs
+@@ -76,22 +76,25 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ {
+ Debug.Assert(expr != null);
+
+- if (expr is ExprLocal local && local.IsOK)
++ if (expr is ExprLocal && ((ExprLocal)expr).IsOK)
+ {
++ ExprLocal local = (ExprLocal)expr;
+ ReportLocalError(local.Local, kind, isNested);
+ return true;
+ }
+
+ Expr pObject = null;
+
+- if (expr is ExprProperty prop)
++ if (expr is ExprProperty)
+ {
++ ExprProperty prop = (ExprProperty)expr;
+ // We've already reported read-only-property errors.
+ Debug.Assert(prop.MethWithTypeSet != null);
+ pObject = prop.MemberGroup.OptionalObject;
+ }
+- else if (expr is ExprField field)
++ else if (expr is ExprField)
+ {
++ ExprField field = (ExprField)expr;
+ if (field.FieldWithType.Field().isReadOnly)
+ {
+ ReportReadOnlyError(field, kind, isNested);
+@@ -105,8 +108,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ if (pObject != null && pObject.Type.isStructOrEnum())
+ {
+- if (pObject is IExprWithArgs withArgs)
++ if (pObject is IExprWithArgs)
+ {
++ IExprWithArgs withArgs = (IExprWithArgs)pObject;
+ // assigning to RHS of method or property getter returning a value-type on the stack or
+ // passing RHS of method or property getter returning a value-type on the stack, as ref or out
+ ErrorContext.Error(ErrorCode.ERR_ReturnNotLValue, withArgs.GetSymWithType());
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs
+index bb62a926b5..873feff72f 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs
+@@ -391,9 +391,10 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ FUNDTYPE ftSrc = expr.Type.fundType();
+ FUNDTYPE ftDest = dest.fundType();
+
+- if (expr is ExprConstant constant && constant.IsOK &&
++ if (expr is ExprConstant && ((ExprConstant)expr).IsOK &&
+ expr.Type.isSimpleType() && dest.isSimpleType())
+ {
++ ExprConstant constant = (ExprConstant) expr;
+ if ((ftSrc == FUNDTYPE.FT_I4 && (ftDest <= FUNDTYPE.FT_LASTNONLONG || ftDest == FUNDTYPE.FT_U8)) ||
+ (ftSrc == FUNDTYPE.FT_I8 && ftDest == FUNDTYPE.FT_U8))
+ {
+@@ -421,8 +422,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ ErrorContext.Error(dest is TypeParameterType ? ErrorCode.ERR_TypeVarCantBeNull : ErrorCode.ERR_ValueCantBeNull, dest);
+ }
+
+- else if (expr is ExprMemberGroup memGrp)
++ else if (expr is ExprMemberGroup)
+ {
++ ExprMemberGroup memGrp = (ExprMemberGroup) expr;
+ BindGrpConversion(memGrp, dest, true);
+ }
+ else if (!TypeManager.TypeContainsAnonymousTypes(dest) && canCast(expr.Type, dest, flags))
+@@ -555,8 +557,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ {
+ ErrorContext.Error(ErrorCode.ERR_ValueCantBeNull, dest);
+ }
+- else if (expr is ExprMemberGroup memGrp)
++ else if (expr is ExprMemberGroup)
+ {
++ ExprMemberGroup memGrp = (ExprMemberGroup)expr;
+ BindGrpConversion(memGrp, dest, true);
+ }
+ else
+@@ -1396,8 +1399,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ for (;;)
+ {
+ Debug.Assert(pExpr != null);
+- if (pExpr is ExprCall call)
++ if (pExpr is ExprCall)
+ {
++ ExprCall call = (ExprCall)pExpr;
+ switch (call.NullableCallLiftKind)
+ {
+ case NullableCallLiftKind.NotLifted:
+@@ -1411,8 +1415,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ continue;
+ }
+ }
+- else if (pExpr is ExprUserDefinedConversion udc)
++ else if (pExpr is ExprUserDefinedConversion)
+ {
++ ExprUserDefinedConversion udc = (ExprUserDefinedConversion)pExpr;
+ pExpr = udc.UserDefinedCall;
+ continue;
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/EXPRExtensions.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/EXPRExtensions.cs
+index 075ed23a11..6408df4c36 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/EXPRExtensions.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/EXPRExtensions.cs
+@@ -33,8 +33,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ Expr exprCur = expr;
+ while (exprCur != null)
+ {
+- if (exprCur is ExprList list)
++ if (exprCur is ExprList)
+ {
++ ExprList list = (ExprList)exprCur;
+ yield return list.OptionalElement;
+ exprCur = list.OptionalNextListNode;
+ }
+@@ -61,12 +62,12 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ }
+ public static bool isNull(this Expr expr)
+ {
+- return expr is ExprConstant constant && constant.IsOK && (expr.Type.fundType() == FUNDTYPE.FT_REF) && constant.Val.IsNullRef;
++ return expr is ExprConstant && ((ExprConstant)expr).IsOK && (expr.Type.fundType() == FUNDTYPE.FT_REF) && ((ExprConstant)expr).Val.IsNullRef;
+ }
+
+ public static bool IsZero(this Expr expr)
+ {
+- return expr is ExprConstant constant && constant.IsOK && constant.IsZero;
++ return expr is ExprConstant && ((ExprConstant)expr).IsOK && ((ExprConstant)expr).IsZero;
+ }
+
+ private static Expr GetSeqVal(this Expr expr)
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExplicitConversion.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExplicitConversion.cs
+index 6ea8879c40..137e950e76 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExplicitConversion.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExplicitConversion.cs
+@@ -207,8 +207,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ VSFAIL("BindExplicitConversion failed unexpectedly");
+ return false;
+ }
+- if (_exprDest is ExprUserDefinedConversion udc)
++ if (_exprDest is ExprUserDefinedConversion)
+ {
++ ExprUserDefinedConversion udc = (ExprUserDefinedConversion)_exprDest;
+ udc.Argument = _exprSrc;
+ }
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs
+index 99ee57626a..ec0d29d6f3 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs
+@@ -265,8 +265,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ ExprUserLogicalOp rval = new ExprUserLogicalOp(pType);
+ Expr leftChild = ((ExprList)pCallOp.OptionalArguments).OptionalElement;
+ Debug.Assert(leftChild != null);
+- if (leftChild is ExprWrap wrap)
++ if (leftChild is ExprWrap)
+ {
++ ExprWrap wrap = (ExprWrap)leftChild;
+ // In the EE case, we don't create WRAPEXPRs.
+ leftChild = wrap.OptionalExpression;
+ Debug.Assert(leftChild != null);
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExpressionBinder.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExpressionBinder.cs
+index 60a1661eac..dc04fa1657 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExpressionBinder.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExpressionBinder.cs
+@@ -601,10 +601,11 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // Check if we have a compile time constant. If we do, create a constant for it and set the
+ // original tree to the cast.
+
+- if (exprConst is ExprConstant constant && exprFlags == 0 &&
++ if (exprConst is ExprConstant && exprFlags == 0 &&
+ exprSrc.Type.fundType() == typeDest.fundType() &&
+- (!exprSrc.Type.isPredefType(PredefinedType.PT_STRING) || constant.Val.IsNullRef))
++ (!exprSrc.Type.isPredefType(PredefinedType.PT_STRING) || ((ExprConstant)exprConst).Val.IsNullRef))
+ {
++ ExprConstant constant = (ExprConstant)exprConst;
+ ExprConstant expr = GetExprFactory().CreateConstant(typeDest, constant.Val);
+ pexprDest = expr;
+ return;
+@@ -1191,8 +1192,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ while (list != null)
+ {
+ Expr arg;
+- if (list is ExprList next)
++ if (list is ExprList)
+ {
++ ExprList next = (ExprList)list;
+ arg = next.OptionalElement;
+ list = next.OptionalNextListNode;
+ }
+@@ -1265,8 +1267,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ private Expr UnwrapExpression(Expr pExpression)
+ {
+- while (pExpression is ExprWrap wrap)
++ while (pExpression is ExprWrap)
+ {
++ ExprWrap wrap = (ExprWrap)pExpression;
+ Expr wrapped = wrap.OptionalExpression;
+ if (wrapped == null)
+ {
+@@ -1344,8 +1347,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ return false;
+ if (expr.isLvalue())
+ {
+- if (expr is ExprProperty prop)
++ if (expr is ExprProperty)
+ {
++ ExprProperty prop = (ExprProperty)expr;
+ CheckLvalueProp(prop);
+ }
+ markFieldAssigned(expr);
+@@ -1571,9 +1575,10 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ // If we're invoking code on a struct-valued field, mark the struct as assigned (to
+ // avoid warning CS0649).
+- if (pObject is ExprField field && !field.FieldWithType.Field().isAssigned && !swt.Sym.IsFieldSymbol() &&
++ if (pObject is ExprField && !((ExprField)pObject).FieldWithType.Field().isAssigned && !swt.Sym.IsFieldSymbol() &&
+ typeObj.isStructType() && !typeObj.isPredefined())
+ {
++ ExprField field = (ExprField) pObject;
+ field.FieldWithType.Field().isAssigned = true;
+ }
+
+@@ -1786,8 +1791,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ Expr argument = indir;
+ Expr rval;
+- if (argument is ExprNamedArgumentSpecification named)
++ if (argument is ExprNamedArgumentSpecification)
+ {
++ ExprNamedArgumentSpecification named = (ExprNamedArgumentSpecification)argument;
+ int index = 0;
+ // If we're named, look for the type of the matching name.
+ foreach (Name i in mostDerivedMethod.ParameterNames)
+@@ -1928,8 +1934,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ Expr expr = it.Current();
+ count++;
+
+- if (expr is ExprNamedArgumentSpecification named)
++ if (expr is ExprNamedArgumentSpecification)
+ {
++ ExprNamedArgumentSpecification named = (ExprNamedArgumentSpecification)expr;
+ named.Value = tryConvert(named.Value, elementType);
+ }
+ else
+@@ -1951,8 +1958,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ private void markFieldAssigned(Expr expr)
+ {
+- if (0 != (expr.Flags & EXPRFLAG.EXF_LVALUE) && expr is ExprField field)
++ if (0 != (expr.Flags & EXPRFLAG.EXF_LVALUE) && expr is ExprField)
+ {
++ ExprField field = (ExprField) expr;
+ FieldSymbol symbol;
+ do
+ {
+@@ -2019,8 +2027,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ for (Expr list = args; list != null; iarg++)
+ {
+ Expr arg;
+- if (list is ExprList next)
++ if (list is ExprList)
+ {
++ ExprList next = (ExprList)list;
+ arg = next.OptionalElement;
+ list = next.OptionalNextListNode;
+ }
+@@ -2374,8 +2383,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ {
+ Expr arg;
+
+- if (list is ExprList next)
++ if (list is ExprList)
+ {
++ ExprList next = (ExprList)list;
+ arg = next.OptionalElement;
+ list = next.OptionalNextListNode;
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/GroupToArgsBinder.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/GroupToArgsBinder.cs
+index 7708f197ae..b75ac340be 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/GroupToArgsBinder.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/GroupToArgsBinder.cs
+@@ -510,7 +510,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // then let us through.
+ if (methprop.isParamArray &&
+ index < pArguments.carg &&
+- pArguments.prgexpr[index] is ExprArrayInit arrayInit && arrayInit.GeneratedForParamArray)
++ pArguments.prgexpr[index] is ExprArrayInit && ((ExprArrayInit)pArguments.prgexpr[index]).GeneratedForParamArray)
+ {
+ paramArrayArgument = pArguments.prgexpr[index];
+ }
+@@ -518,7 +518,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // Positional.
+ if (index < pArguments.carg &&
+ !(pArguments.prgexpr[index] is ExprNamedArgumentSpecification) &&
+- !(pArguments.prgexpr[index] is ExprArrayInit arrayInitPos && arrayInitPos.GeneratedForParamArray))
++ !(pArguments.prgexpr[index] is ExprArrayInit && ((ExprArrayInit)pArguments.prgexpr[index]).GeneratedForParamArray))
+ {
+ pExprArguments[index] = pArguments.prgexpr[index++];
+ continue;
+@@ -839,7 +839,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ for (int i = 0; i < pArguments.carg; i++)
+ {
+ Expr expr = prgexpr[i];
+- if (expr is ExprNamedArgumentSpecification named && named.Name == pName)
++ if (expr is ExprNamedArgumentSpecification && ((ExprNamedArgumentSpecification)expr).Name == pName)
+ {
+ return expr;
+ }
+@@ -861,7 +861,8 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ HashSet<Name> names = new HashSet<Name>();
+ for (int i = 0; i < _pArguments.carg; i++)
+ {
+- if (!(_pArguments.prgexpr[i] is ExprNamedArgumentSpecification named))
++ ExprNamedArgumentSpecification named;
++ if (!(_pArguments.prgexpr[i] is ExprNamedArgumentSpecification))
+ {
+ if (!currentPosition.IsEmpty())
+ {
+@@ -869,6 +870,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ }
+ continue;
+ }
++ named = (ExprNamedArgumentSpecification) _pArguments.prgexpr[i];
+
+ Name name = named.Name;
+ if (!methprop.ParameterNames.Contains(name))
+@@ -1080,8 +1082,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ Expr pArgument = _pArguments.prgexpr[ivar];
+
+ // If we have a named argument, strip it to do the conversion.
+- if (pArgument is ExprNamedArgumentSpecification named)
++ if (pArgument is ExprNamedArgumentSpecification)
+ {
++ ExprNamedArgumentSpecification named = (ExprNamedArgumentSpecification)pArgument;
+ pArgument = named.Value;
+ }
+
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ImplicitConversion.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ImplicitConversion.cs
+index f1a0159e53..fdbd1dd426 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ImplicitConversion.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ImplicitConversion.cs
+@@ -172,8 +172,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ VSFAIL("Bad type symbol kind");
+ break;
+ case TypeKind.TK_MethodGroupType:
+- if (_exprSrc is ExprMemberGroup memGrp)
++ if (_exprSrc is ExprMemberGroup)
+ {
++ ExprMemberGroup memGrp = (ExprMemberGroup)_exprSrc;
+ ExprCall outExpr;
+ bool retVal = _binder.BindGrpConversion(memGrp, _typeDest, _needsExprDest, out outExpr, false);
+ _exprDest = outExpr;
+@@ -744,10 +745,10 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // * A constant-expression of type long can be converted to type ulong, provided the value of
+ // the constant-expression is not negative.
+ // Note: Don't use GetConst here since the conversion only applies to bona-fide compile time constants.
+- if (_exprSrc is ExprConstant constant && _exprSrc.IsOK &&
++ if (_exprSrc is ExprConstant && _exprSrc.IsOK &&
+ ((ptSrc == PredefinedType.PT_INT && ptDest != PredefinedType.PT_BOOL && ptDest != PredefinedType.PT_CHAR) ||
+ (ptSrc == PredefinedType.PT_LONG && ptDest == PredefinedType.PT_ULONG)) &&
+- isConstantInRange(constant, _typeDest))
++ isConstantInRange(((ExprConstant)_exprSrc), _typeDest))
+ {
+ // Special case (CLR 6.1.6): if integral constant is in range, the conversion is a legal implicit conversion.
+ convertKind = ConvKind.Implicit;
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs
+index 589b9c96d0..2559ca5c85 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs
+@@ -1064,10 +1064,11 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // SPEC: yields a single method with return CType U then a lower-bound
+ // SPEC: inference is made from U to Tb.
+
+- if (!(pSource is ExprMemberGroup memGrp))
++ if (!(pSource is ExprMemberGroup))
+ {
+ return false;
+ }
++ ExprMemberGroup memGrp = (ExprMemberGroup)pSource;
+ pType = pType.GetDelegateTypeOfPossibleExpression();
+ if (!pType.isDelegateType())
+ {
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Nullable.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Nullable.cs
+index 19dbea7e2f..1d258f2d67 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Nullable.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Nullable.cs
+@@ -29,8 +29,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ {
+ Debug.Assert(expr != null);
+
+- if (expr is ExprCall pCall && pCall.MemberGroup.OptionalObject == null)
++ if (expr is ExprCall && ((ExprCall)expr).MemberGroup.OptionalObject == null)
+ {
++ ExprCall pCall = (ExprCall)expr;
+ MethodSymbol meth = pCall.MethWithInst.Meth();
+ if (meth != null && meth.IsNullableConstructor())
+ {
+@@ -45,7 +46,8 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+
+ public static Expr StripNullableConstructor(Expr pExpr)
+ {
+- while (IsNullableConstructor(pExpr, out ExprCall call))
++ ExprCall call;
++ while (IsNullableConstructor(pExpr, out call))
+ {
+ pExpr = call.OptionalArguments;
+ Debug.Assert(pExpr != null && !(pExpr is ExprList));
+@@ -60,7 +62,8 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ Debug.Assert(exprSrc != null && exprSrc.Type.IsNullableType());
+
+ // For new T?(x), the answer is x.
+- if (IsNullableConstructor(exprSrc, out ExprCall call))
++ ExprCall call;
++ if (IsNullableConstructor(exprSrc, out call))
+ {
+ var args = call.OptionalArguments;
+ Debug.Assert(args != null && !(args is ExprList));
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/ExpressionIterator.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/ExpressionIterator.cs
+index 96ee032422..9397543de6 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/ExpressionIterator.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/ExpressionIterator.cs
+@@ -83,8 +83,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ _pList = null;
+ _pCurrent = null;
+ }
+- else if (pExpr is ExprList pList)
++ else if (pExpr is ExprList)
+ {
++ ExprList pList = (ExprList)pExpr;
+ _pList = pList;
+ _pCurrent = pList.OptionalElement;
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExprVisitorBase.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExprVisitorBase.cs
+index e2ce8e88f5..ded4d0b216 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExprVisitorBase.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExprVisitorBase.cs
+@@ -21,8 +21,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ return pResult;
+ }
+
+- if (pExpr is ExprStatement statement)
++ if (pExpr is ExprStatement)
+ {
++ ExprStatement statement = (ExprStatement)pExpr;
+ return CacheExprMapping(pExpr, DispatchStatementList(statement));
+ }
+
+@@ -279,11 +280,13 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ return;
+ }
+
+- if (!(nextNode is ExprList next))
++ ExprList next;
++ if (!(nextNode is ExprList))
+ {
+ list.OptionalNextListNode = Visit(nextNode);
+ return;
+ }
++ next = (ExprList)nextNode;
+
+ list = next;
+ }
+diff --git a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExpressionTreeRewriter.cs b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExpressionTreeRewriter.cs
+index 8a841ee5d9..cb40a59f6d 100644
+--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExpressionTreeRewriter.cs
++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Tree/Visitors/ExpressionTreeRewriter.cs
+@@ -54,8 +54,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // For assignments, we either have a member assignment or an indexed assignment.
+ //Debug.Assert(assignment.GetLHS().isPROP() || assignment.GetLHS().isFIELD() || assignment.GetLHS().isARRAYINDEX() || assignment.GetLHS().isLOCAL());
+ Expr lhs;
+- if (assignment.LHS is ExprProperty prop)
++ if (assignment.LHS is ExprProperty)
+ {
++ ExprProperty prop = (ExprProperty)assignment.LHS;
+ if (prop.OptionalArguments== null)
+ {
+ // Regular property.
+@@ -318,8 +319,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ // can handle in the general case all implicit boxing conversions. Right now it
+ // requires that all arguments to a call that need to be boxed be explicitly boxed.
+
+- if (pObject != null && pObject is ExprCast cast && cast.IsBoxingCast)
++ if (pObject != null && pObject is ExprCast && ((ExprCast)pObject).IsBoxingCast)
+ {
++ ExprCast cast = (ExprCast) pObject;
+ pObject = cast.Argument;
+ }
+ pObject = Visit(pObject);
+@@ -597,8 +599,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ if (udcall != null)
+ {
+ Debug.Assert(udcall.Kind == ExpressionKind.Call || udcall.Kind == ExpressionKind.UserLogicalOp);
+- if (udcall is ExprCall ascall)
++ if (udcall is ExprCall)
+ {
++ ExprCall ascall = (ExprCall)udcall;
+ ExprList args = (ExprList)ascall.OptionalArguments;
+ Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List);
+ p1 = args.OptionalElement;
+@@ -731,8 +734,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ ExprBlock body = anonmeth.OptionalBody;
+
+ // The most likely case:
+- if (body.OptionalStatements is ExprReturn ret)
++ if (body.OptionalStatements is ExprReturn)
+ {
++ ExprReturn ret = (ExprReturn)body.OptionalStatements;
+ Debug.Assert(ret.OptionalObject != null);
+ return Visit(ret.OptionalObject);
+ }
+@@ -854,8 +858,9 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ Expr pUDConversion = call?.PConversions;
+ if (pUDConversion != null)
+ {
+- if (pUDConversion is ExprCall convCall)
++ if (pUDConversion is ExprCall)
+ {
++ ExprCall convCall = (ExprCall)pUDConversion;
+ Expr pUDConversionArgument = convCall.OptionalArguments;
+ if (IsNullableValueAccess(pUDConversionArgument, pArgument))
+ {
+@@ -1238,23 +1243,25 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics
+ private bool IsNullableValueAccess(Expr pExpr, Expr pObject)
+ {
+ Debug.Assert(pExpr != null);
+- return pExpr is ExprProperty prop && prop.MemberGroup.OptionalObject == pObject && pObject.Type.IsNullableType();
++ return pExpr is ExprProperty && ((ExprProperty)pExpr).MemberGroup.OptionalObject == pObject && pObject.Type.IsNullableType();
+ }
+
+ private bool IsDelegateConstructorCall(Expr pExpr)
+ {
+ Debug.Assert(pExpr != null);
+- if (!(pExpr is ExprCall pCall))
++ ExprCall pCall;
++ if (!(pExpr is ExprCall))
+ {
+ return false;
+ }
++ pCall = (ExprCall)pExpr;
+
+ return pCall.MethWithInst.Meth() != null &&
+ pCall.MethWithInst.Meth().IsConstructor() &&
+ pCall.Type.isDelegateType() &&
+ pCall.OptionalArguments != null &&
+- pCall.OptionalArguments is ExprList list &&
+- list.OptionalNextListNode.Kind == ExpressionKind.FunctionPointer;
++ (pCall.OptionalArguments is ExprList) &&
++ ((ExprList)pCall.OptionalArguments).OptionalNextListNode.Kind == ExpressionKind.FunctionPointer;
+ }
+ private static bool isEnumToDecimalConversion(CType argtype, CType desttype)
+ {
+diff --git a/src/System.Collections/src/System/Collections/Generic/SortedSet.TreeSubSet.cs b/src/System.Collections/src/System/Collections/Generic/SortedSet.TreeSubSet.cs
+index 4eb817c0af..671636f428 100644
+--- a/src/System.Collections/src/System/Collections/Generic/SortedSet.TreeSubSet.cs
++++ b/src/System.Collections/src/System/Collections/Generic/SortedSet.TreeSubSet.cs
+@@ -352,7 +352,10 @@ namespace System.Collections.Generic
+ throw new PlatformNotSupportedException();
+ }
+
+- protected override void OnDeserialization(Object sender) => throw new PlatformNotSupportedException();
++ protected override void OnDeserialization(Object sender)
++ {
++ throw new PlatformNotSupportedException();
++ }
+ }
+ }
+ }
+diff --git a/src/System.Linq.Expressions/src/System/Dynamic/Utils/TypeExtensions.cs b/src/System.Linq.Expressions/src/System/Dynamic/Utils/TypeExtensions.cs
+index c45caba093..ef9a25203d 100644
+--- a/src/System.Linq.Expressions/src/System/Dynamic/Utils/TypeExtensions.cs
++++ b/src/System.Linq.Expressions/src/System/Dynamic/Utils/TypeExtensions.cs
+@@ -65,7 +65,8 @@ namespace System.Dynamic.Utils
+ internal static ParameterInfo[] GetParametersCached(this MethodBase method)
+ {
+ CacheDict<MethodBase, ParameterInfo[]> pic = s_paramInfoCache;
+- if (!pic.TryGetValue(method, out ParameterInfo[] pis))
++ ParameterInfo[] pis;
++ if (!pic.TryGetValue(method, out pis))
+ {
+ pis = method.GetParameters();
+
+diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
+index d8b1c61f74..8cefbd4f19 100644
+--- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
++++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
+@@ -952,8 +952,9 @@ namespace System.Linq.Expressions.Compiler
+ private void EmitMemberAssignment(MemberAssignment binding, Type objectType)
+ {
+ EmitExpression(binding.Expression);
+- if (binding.Member is FieldInfo fi)
++ if (binding.Member is FieldInfo)
+ {
++ FieldInfo fi = (FieldInfo)binding.Member;
+ _ilg.Emit(OpCodes.Stfld, fi);
+ }
+ else
+@@ -1097,7 +1098,7 @@ namespace System.Linq.Expressions.Compiler
+ private static Type GetMemberType(MemberInfo member)
+ {
+ Debug.Assert(member is FieldInfo || member is PropertyInfo);
+- return member is FieldInfo fi ? fi.FieldType : (member as PropertyInfo).PropertyType;
++ return member is FieldInfo ? ((FieldInfo)member).FieldType : (member as PropertyInfo).PropertyType;
+ }
+
+ #endregion
+diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberAssignment.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberAssignment.cs
+index 475a6c63cc..0787b10186 100644
+--- a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberAssignment.cs
++++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberAssignment.cs
+@@ -93,23 +93,23 @@ namespace System.Linq.Expressions
+
+ // Null paramName as there are two paths here with different parameter names at the API
+ TypeUtils.ValidateType(decType, null);
+- switch (member)
++ if (member is PropertyInfo)
+ {
+- case PropertyInfo pi:
+- if (!pi.CanWrite)
+- {
+- throw Error.PropertyDoesNotHaveSetter(pi, nameof(member));
+- }
+-
+- memberType = pi.PropertyType;
+- break;
+-
+- case FieldInfo fi:
+- memberType = fi.FieldType;
+- break;
+-
+- default:
+- throw Error.ArgumentMustBeFieldInfoOrPropertyInfo(nameof(member));
++ PropertyInfo pi = (PropertyInfo) member;
++ if (!pi.CanWrite)
++ {
++ throw Error.PropertyDoesNotHaveSetter(pi, nameof(member));
++ }
++ memberType = pi.PropertyType;
++ }
++ else if (member is FieldInfo)
++ {
++ FieldInfo fi = (FieldInfo) member;
++ memberType = fi.FieldType;
++ }
++ else
++ {
++ throw Error.ArgumentMustBeFieldInfoOrPropertyInfo(nameof(member));
+ }
+ }
+ }
+diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberBinding.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberBinding.cs
+index c1c5884618..43c0698f90 100644
+--- a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberBinding.cs
++++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberBinding.cs
+@@ -61,6 +61,9 @@ namespace System.Linq.Expressions
+ return ExpressionStringBuilder.MemberBindingToString(this);
+ }
+
+- internal virtual void ValidateAsDefinedHere(int index) => throw Error.UnknownBindingType(index);
++ internal virtual void ValidateAsDefinedHere(int index)
++ {
++ throw Error.UnknownBindingType(index);
++ }
+ }
+ }
+diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberMemberBinding.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberMemberBinding.cs
+index f3981a2b1f..75dd7141da 100644
+--- a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberMemberBinding.cs
++++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberMemberBinding.cs
+@@ -127,23 +127,24 @@ namespace System.Linq.Expressions
+
+ // Null paramName as there are several paths here with different parameter names at the API
+ TypeUtils.ValidateType(decType, null, allowByRef: true, allowPointer: true);
+- switch (member)
++ if (member is PropertyInfo)
+ {
+- case PropertyInfo pi:
+- if (!pi.CanRead)
+- {
+- throw Error.PropertyDoesNotHaveGetter(pi, nameof(member));
+- }
+-
+- memberType = pi.PropertyType;
+- break;
+-
+- case FieldInfo fi:
+- memberType = fi.FieldType;
+- break;
++ PropertyInfo pi = (PropertyInfo)member;
++ if (!pi.CanRead)
++ {
++ throw Error.PropertyDoesNotHaveGetter(pi, nameof(member));
++ }
+
+- default:
+- throw Error.ArgumentMustBeFieldInfoOrPropertyInfo(nameof(member));
++ memberType = pi.PropertyType;
++ }
++ else if (member is FieldInfo)
++ {
++ FieldInfo fi = (FieldInfo)member;
++ memberType = fi.FieldType;
++ }
++ else
++ {
++ throw Error.ArgumentMustBeFieldInfoOrPropertyInfo(nameof(member));
+ }
+ }
+
+diff --git a/src/System.Net.HttpListener/src/System/Net/WebSockets/HttpListenerWebSocketContext.cs b/src/System.Net.HttpListener/src/System/Net/WebSockets/HttpListenerWebSocketContext.cs
+index 5321578946..ff54677027 100644
+--- a/src/System.Net.HttpListener/src/System/Net/WebSockets/HttpListenerWebSocketContext.cs
++++ b/src/System.Net.HttpListener/src/System/Net/WebSockets/HttpListenerWebSocketContext.cs
+@@ -94,8 +94,9 @@ namespace System.Net.WebSockets
+ if (!(user is WindowsPrincipal))
+ {
+ // AuthenticationSchemes.Basic.
+- if (user.Identity is HttpListenerBasicIdentity basicIdentity)
++ if (user.Identity is HttpListenerBasicIdentity)
+ {
++ HttpListenerBasicIdentity basicIdentity = (HttpListenerBasicIdentity)user.Identity;
+ return new GenericPrincipal(new HttpListenerBasicIdentity(basicIdentity.Name, basicIdentity.Password), null);
+ }
+ }
diff --git a/gnu/packages/patches/mono-5.4.0-patches.patch b/gnu/packages/patches/mono-5.4.0-patches.patch
new file mode 100644
index 00000000000..007a6b847c6
--- /dev/null
+++ b/gnu/packages/patches/mono-5.4.0-patches.patch
@@ -0,0 +1,100 @@
+diff --git a/mcs/class/System/Mono.Net.Security/AsyncProtocolRequest.cs b/mcs/class/System/Mono.Net.Security/AsyncProtocolRequest.cs
+index 3c537a7e427..59beb19255f 100644
+--- a/mcs/class/System/Mono.Net.Security/AsyncProtocolRequest.cs
++++ b/mcs/class/System/Mono.Net.Security/AsyncProtocolRequest.cs
+@@ -316,7 +316,9 @@ namespace Mono.Net.Security
+ {
+ Debug ("ProcessRead - read user: {0} {1}", this, status);
+
+- var (ret, wantMore) = Parent.ProcessRead (UserBuffer);
++ System.ValueTuple<int, bool> t0 = Parent.ProcessRead (UserBuffer);
++ var ret = t0.Item1;
++ var wantMore = t0.Item2;
+
+ Debug ("ProcessRead - read user done: {0} - {1} {2}", this, ret, wantMore);
+
+@@ -355,7 +357,9 @@ namespace Mono.Net.Security
+ return AsyncOperationStatus.Complete;
+ }
+
+- var (ret, wantMore) = Parent.ProcessWrite (UserBuffer);
++ System.ValueTuple<int, bool> t0 = Parent.ProcessWrite (UserBuffer);
++ var ret = t0.Item1;
++ var wantMore = t0.Item2;
+
+ Debug ("ProcessWrite - write user done: {0} - {1} {2}", this, ret, wantMore);
+
+diff --git a/mcs/class/System/Mono.Net.Security/MobileAuthenticatedStream.cs b/mcs/class/System/Mono.Net.Security/MobileAuthenticatedStream.cs
+index 2b380a1ae6c..66e45bc1f1d 100644
+--- a/mcs/class/System/Mono.Net.Security/MobileAuthenticatedStream.cs
++++ b/mcs/class/System/Mono.Net.Security/MobileAuthenticatedStream.cs
+@@ -403,8 +403,10 @@ namespace Mono.Net.Security
+ asyncReadRequest != null ? "async" : "",
+ readBuffer != null ? readBuffer.ToString () : "");
+ var asyncRequest = asyncHandshakeRequest ?? asyncReadRequest;
+- var (ret, wantMore) = InternalRead (asyncRequest, readBuffer, buffer, offset, size);
+- outWantMore = wantMore;
++ System.ValueTuple<int, bool> t0 = InternalRead (asyncRequest, readBuffer, buffer, offset, size);
++ var ret = t0.Item1;
++ var wantMore = t0.Item2;
++ outWantMore = wantMore;
+ return ret;
+ } catch (Exception ex) {
+ Debug ("InternalRead failed: {0}", ex);
+@@ -414,7 +416,7 @@ namespace Mono.Net.Security
+ }
+ }
+
+- (int, bool) InternalRead (AsyncProtocolRequest asyncRequest, BufferOffsetSize internalBuffer, byte[] buffer, int offset, int size)
++ System.ValueTuple<int, bool> InternalRead (AsyncProtocolRequest asyncRequest, BufferOffsetSize internalBuffer, byte[] buffer, int offset, int size)
+ {
+ if (asyncRequest == null)
+ throw new InvalidOperationException ();
+@@ -436,7 +438,7 @@ namespace Mono.Net.Security
+ Debug ("InternalRead #1: {0} {1} {2}", internalBuffer.Offset, internalBuffer.TotalBytes, size);
+ internalBuffer.Offset = internalBuffer.Size = 0;
+ asyncRequest.RequestRead (size);
+- return (0, true);
++ return new ValueTuple<int, bool>(0, true);
+ }
+
+ /*
+@@ -451,7 +453,7 @@ namespace Mono.Net.Security
+ Buffer.BlockCopy (internalBuffer.Buffer, internalBuffer.Offset, buffer, offset, len);
+ internalBuffer.Offset += len;
+ internalBuffer.Size -= len;
+- return (len, !internalBuffer.Complete && len < size);
++ return new ValueTuple<int, bool>(len, !internalBuffer.Complete && len < size);
+ }
+
+ /*
+@@ -620,21 +622,23 @@ namespace Mono.Net.Security
+ }
+ }
+
+- internal (int, bool) ProcessRead (BufferOffsetSize userBuffer)
++ internal System.ValueTuple<int, bool> ProcessRead (BufferOffsetSize userBuffer)
+ {
+ lock (ioLock) {
+ // This operates on the internal buffer and will never block.
+- var ret = xobileTlsContext.Read (userBuffer.Buffer, userBuffer.Offset, userBuffer.Size, out bool wantMore);
+- return (ret, wantMore);
++ bool wantMore;
++ var ret = xobileTlsContext.Read (userBuffer.Buffer, userBuffer.Offset, userBuffer.Size, out wantMore);
++ return new System.ValueTuple<int, bool>(ret, wantMore);
+ }
+ }
+
+- internal (int, bool) ProcessWrite (BufferOffsetSize userBuffer)
++ internal System.ValueTuple<int, bool> ProcessWrite (BufferOffsetSize userBuffer)
+ {
+ lock (ioLock) {
+ // This operates on the internal buffer and will never block.
+- var ret = xobileTlsContext.Write (userBuffer.Buffer, userBuffer.Offset, userBuffer.Size, out bool wantMore);
+- return (ret, wantMore);
++ bool wantMore;
++ var ret = xobileTlsContext.Write (userBuffer.Buffer, userBuffer.Offset, userBuffer.Size, out wantMore);
++ return new System.ValueTuple<int, bool>(ret, wantMore);
+ }
+ }
+
--
Efraim Flashner <efraim <at> flashner.co.il> אפרים פלשנר
GPG key = A28B F40C 3E55 1372 662D 14F7 41AA E7DC CA3D 8351
Confidentiality cannot be guaranteed on emails sent or received unencrypted
GNU bug tracking system
Copyright (C) 1999 Darren O. Benham,
1997,2003 nCipher Corporation Ltd,
1994-97 Ian Jackson.