From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mp0.migadu.com ([2001:41d0:303:e224::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by ms13.migadu.com with LMTPS id 0C3UKNdjYGcSDAEAqHPOHw:P1 (envelope-from ) for ; Mon, 16 Dec 2024 17:31:03 +0000 Received: from aspmx1.migadu.com ([2001:41d0:303:e224::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by mp0.migadu.com with LMTPS id 0C3UKNdjYGcSDAEAqHPOHw (envelope-from ) for ; Mon, 16 Dec 2024 18:31:03 +0100 X-Envelope-To: larch@yhetil.org Authentication-Results: aspmx1.migadu.com; dkim=pass header.d=debbugs.gnu.org header.s=debbugs-gnu-org header.b=r8+PO2Qx; dkim=fail ("headers rsa verify failed") header.d=gmail.com header.s=20230601 header.b=NDEPElQJ; dmarc=none; spf=pass (aspmx1.migadu.com: domain of "guix-patches-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="guix-patches-bounces+larch=yhetil.org@gnu.org" ARC-Seal: i=1; s=key1; d=yhetil.org; t=1734370261; a=rsa-sha256; cv=none; b=SWU73YzgAUUQ5C/LERWGM9yHaovo4uW2YpfeJvdhS4aX0NJ0tJE49KYV9Fv7WpWMawpywv PP8ToKkCOJW8jproBK3rS2QQG6d+/M6MLPwEj9vGqTZVzB59OnVjE/ALwujbzEa3xsH0GB hJM2W5RQ8WUTTnrZWqWOpiX6c2VGOsCkc218fxM2BIWG2l/Kwz9089nNDhIVVbmFZkp1hA bLftMGDpTmWUKVAmfNUd4n6T8gtyiKk6ClQj1+N47gIQbYJypy/HjsrTfX94CqgjvXFuAk W9U7d+aSIcSU+VWiUl0I1oVK2emFJb+vF15ni0jG+zWRHaM0wYA7VmDYhWybQw== ARC-Authentication-Results: i=1; aspmx1.migadu.com; dkim=pass header.d=debbugs.gnu.org header.s=debbugs-gnu-org header.b=r8+PO2Qx; dkim=fail ("headers rsa verify failed") header.d=gmail.com header.s=20230601 header.b=NDEPElQJ; dmarc=none; spf=pass (aspmx1.migadu.com: domain of "guix-patches-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="guix-patches-bounces+larch=yhetil.org@gnu.org" ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=yhetil.org; s=key1; t=1734370261; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding:resent-cc: resent-from:resent-sender:resent-message-id:in-reply-to:in-reply-to: references:references:list-id:list-help:list-unsubscribe: list-subscribe:list-post:dkim-signature; bh=FJzf3Yu805ZxZjOLZlalAc92J1yXEvJu2+FSS76YD48=; b=eJV/n3bFxyTmISd9Tk7W5BdTq/m7ubeY9GZ+NYVaChPiJ+pfnK8Y6qL+V11EvIDbyCoIsM u74TC0XWPz+YNfc8NTLVDgeN72fpTGKRq0ko05iFP2mM7tkn+CILZg+CwFpj1GDYLAhoYq j639c24G5ILPDfOqU4Flqc2Cce6UCjxGuV5fMWBf3OrR9uENI1Ivjh+zS/qt4H4G7vAIV/ Em9bs3yaDe04VARBn3uWJZs/pd5p+Tj0PIT/cPxIOHrAAZo3sepFJKiYdTkaCsvwDqiuO9 825bU59zqYBgQ5n0vCqf0klE2nR7kf51Sq059I67aAfYY48xtvGk0SncgHOSSQ== Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by aspmx1.migadu.com (Postfix) with ESMTPS id A42989F5 for ; Mon, 16 Dec 2024 18:30:53 +0100 (CET) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1tNEvf-0001T7-Af; Mon, 16 Dec 2024 12:30:49 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tNEuE-0000QS-HS for guix-patches@gnu.org; Mon, 16 Dec 2024 12:29:19 -0500 Received: from debbugs.gnu.org ([2001:470:142:5::43]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1tNEuA-0001wp-I3 for guix-patches@gnu.org; Mon, 16 Dec 2024 12:29:17 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=debbugs.gnu.org; s=debbugs-gnu-org; h=MIME-Version:References:In-Reply-To:Date:From:To:Subject; bh=FJzf3Yu805ZxZjOLZlalAc92J1yXEvJu2+FSS76YD48=; b=r8+PO2QxgLATzI+dYc7Bo8jK2vhGf18LlzP7zxdGLt1GNkHtJ9gIq3//fW1OuXWL2dA1Cs4aUrv7luKZPGs1vVs8pautULdiE0yT9O2EAo2bK5qcZaHH1Wn+90uKhW83TShSOSzi5VSCtAMt6wdm68I7d/hb4+OZdvoBWV0slQnKU5caRPOnC9Q1IfNG/DBFIkaAeGvThDbaH4UpCBhdB5De64QvpPZ3brcjLI20Zy50zSjicZk97OZ0fixCi6WV6f8HpR41BKgFADBVfW4yNxgD4BwybxFTQax2G4sr4NkYXjTzsPABPb8gHKOyXoS/iGuu0jytJR4hnJphFXAEZQ==; Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1tNEuA-0006MJ-7P for guix-patches@gnu.org; Mon, 16 Dec 2024 12:29:14 -0500 X-Loop: help-debbugs@gnu.org Subject: [bug#74609] [PATCH 16/21] gnu: Add mono-pre-5.8.0. Resent-From: Efraim Flashner Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Mon, 16 Dec 2024 17:29:14 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 74609 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 74609@debbugs.gnu.org Cc: aaron.covrig.us@ieee.org, ludo@gnu.org, unmush , richard@freakingpenguin.com, unmush@proton.me, janneke@gnu.org Received: via spool by 74609-submit@debbugs.gnu.org id=B74609.173437013824241 (code B ref 74609); Mon, 16 Dec 2024 17:29:14 +0000 Received: (at 74609) by debbugs.gnu.org; 16 Dec 2024 17:28:58 +0000 Received: from localhost ([127.0.0.1]:55873 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tNEtp-0006IN-L6 for submit@debbugs.gnu.org; Mon, 16 Dec 2024 12:28:57 -0500 Received: from mail-wr1-f48.google.com ([209.85.221.48]:56801) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tNEtg-0006HX-9w for 74609@debbugs.gnu.org; Mon, 16 Dec 2024 12:28:49 -0500 Received: by mail-wr1-f48.google.com with SMTP id ffacd0b85a97d-385ddcfc97bso3684874f8f.1 for <74609@debbugs.gnu.org>; Mon, 16 Dec 2024 09:28:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1734370064; x=1734974864; darn=debbugs.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:from:to:cc:subject:date :message-id:reply-to; bh=FJzf3Yu805ZxZjOLZlalAc92J1yXEvJu2+FSS76YD48=; b=NDEPElQJbREjX12eaZW5Endd0pVxgCD11KGo0+U7VH3Gk1JqqKqffNahJMWNlaOvhs 5KnoaCDBi/yxzvLlsRpk/PrwQUnfsJ2zKBZ464HLth+5aI2x8DbP2Tm4kSOvCF+7Rrdx Ag/9UTE1M0B+R4r4wDs2CdNSiF3FL/U3Q6eXdqC1kiW/26xAIlEoWer3JV1kBCcBBS5D VySPW7DHKNP/2BR0Xnl3MnB2jq7jqcnPb5HkT+CPc1dFXEm/NUpf9zlkif97kQqIh+eJ FbGD6vt5r2hfSBSTd+UX5+dNUQ18BNUMqS7Eh0FVucvdRt40EY+5Ht3LLbfbjUf3zkAo 2v8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1734370064; x=1734974864; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=FJzf3Yu805ZxZjOLZlalAc92J1yXEvJu2+FSS76YD48=; b=DFu553aNYNv2PrF2MuwhelfK5relRYiRGTLEFXS/VHSCSBQFOSAVZ4/7qRvwVU/si5 e8y8lkSZW/cKC1TB8dsj0ms4n8RKPiXSqu+8AnMmTodfznvNp7KjKO5xwCGBtXoP90nm 52VNgwTG5z3jF3Q44Yneq7PrvDXE+kZgQVPbdKCWWADgue1zjWEtGozfEKxoXiJD9/Gj s3q26gVBqqt8gaiXlf3W3TF2r1+7cCeF2AkdfISfZU/rrnSVX45SWdHxqU6XsLP/8xRG W7YVNlbRdeT4DjKGEtwfNF8zRf6ylfoddUyySMjLHFtph+UDMrKWUlLXtf0hvTRoQbv/ +Bpw== X-Gm-Message-State: AOJu0YyRprNQqWD21q6hhIkisAvMLD8mkHRAyYpkMAKLErRb094fd7Xx rtEZbVxyBa9mu3l4QdZAiykW8LwdXPPB2W6qRCNXmiz0SBApvfuYq4A9ArpR X-Gm-Gg: ASbGncsVagP6vyImav16G0dFqH/x26WrxjkzhkHuTDPvIhxSA2FFy5G3cOC375qlv5U 9u9IkzPy+QeBx1lCkmrygIg8xGzgLVRw8CrbsuGIzwNHnj4cUexHweJ7d6yRGvNl/2/R1mA7d2G NKo7XiuXbZ41Sgr0DMkpzZ6HLDdkm8a6W8VSg734KXCZ96z8N9HTSoduKcfPZIf+KWOoeOiNaCu 2ZN6U60Wz3zOpYLPJjiAOA+gLvHkl5FrjYwHaqQOzxd0Z1GpbUWsOnE1CVL6w== X-Google-Smtp-Source: AGHT+IFLjs1Sst3K48TSGDE7Z3/S98glYPxjA+GotnPAHRDmoPvXG0agPnxQVsCSmUVmGKd6y1P4BQ== X-Received: by 2002:a05:6000:4615:b0:386:2ebe:7ac3 with SMTP id ffacd0b85a97d-3889ad37d13mr11206367f8f.56.1734370063138; Mon, 16 Dec 2024 09:27:43 -0800 (PST) Received: from localhost ([31.210.180.118]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-388c801211dsm8688480f8f.17.2024.12.16.09.27.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Dec 2024 09:27:42 -0800 (PST) From: Efraim Flashner Date: Mon, 16 Dec 2024 19:26:39 +0200 Message-ID: X-Mailer: git-send-email 2.46.0 In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list X-BeenThere: guix-patches@gnu.org List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guix-patches-bounces+larch=yhetil.org@gnu.org Sender: guix-patches-bounces+larch=yhetil.org@gnu.org X-Migadu-Country: US X-Migadu-Flow: FLOW_IN X-Migadu-Spam-Score: -5.65 X-Spam-Score: -5.65 X-Migadu-Queue-Id: A42989F5 X-Migadu-Scanner: mx12.migadu.com X-TUID: 5mExy1pSSrc2 From: unmush * gnu/packages/dotnet.scm (mono-pre-5.8.0-external-repo-specs, mono-pre-5.8.0): New variable. * gnu/packages/patches/corefx-mono-pre-5.8.0-patches.patch: New patch. * gnu/local.mk (dist_patch_DATA): Register new patch. Change-Id: Id573b051e01980867a07032f339fdb2829b2a413 --- gnu/local.mk | 1 + gnu/packages/dotnet.scm | 79 + .../corefx-mono-pre-5.8.0-patches.patch | 1349 +++++++++++++++++ 3 files changed, 1429 insertions(+) create mode 100644 gnu/packages/patches/corefx-mono-pre-5.8.0-patches.patch diff --git a/gnu/local.mk b/gnu/local.mk index aa129d89d58..788f3bb835a 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1115,6 +1115,7 @@ dist_patch_DATA = \ %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/corefx-mono-pre-5.8.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\ diff --git a/gnu/packages/dotnet.scm b/gnu/packages/dotnet.scm index b4355b048e2..7799f9b951a 100644 --- a/gnu/packages/dotnet.scm +++ b/gnu/packages/dotnet.scm @@ -1196,3 +1196,82 @@ (define-public mono-5.4.0 "mono-5.4.0-patches.patch")))) (native-inputs (modify-inputs (package-native-inputs mono-5.2.0) (replace "mono" mono-5.2.0))))) + +(define mono-pre-5.8.0-external-repo-specs + '(("api-doc-tools" "d03e819838c6241f92f90655cb448cc47c9e8791" + "1riki79f3ig3cxigviss81dz601hn92a1gifglm0mzjbs76sf3fj" + #:recursive? #t) + ("api-snapshot" "e790a9b77031ef1d8ebf093ef88840edea11ed73" + "1c4np2fqd9mpc1i1x8bsxnypacp58vkvgdwpnmvmlyjdvbj5ax6q") + ("aspnetwebstack" "e77b12e6cc5ed260a98447f609e887337e44e299" + "0rks344qr4fmp3fs1264d2qkmm348m8d1kjd7z4l94iiirwn1fq1") + (("reference-assemblies" "binary-reference-assemblies") + "142cbeb62ffabf1dd9c1414d8dd76f93bcbed0c2" + "1wkd589hgb16m5zvmp9yb57agyyryaa1jj8vhl4w20i2hp22wad9") + ("bockbuild" "b445017309aac741a26d8c51bb0636234084bf23" + "1jzhvavd1j0n7sy1waczgjv0kmrbr35gkzd76fhlmqvsy0sr9695") + ("boringssl" "3e0770e18835714708860ba9fe1af04a932971ff" + "139a0gl91a52k2r6na6ialzkqykaj1rk88zjrkaz3sdxx7nmmg6y") + ("cecil" "c76ba7b410447fa37093150cb7bc772cba28a0ae" + "0ydi7rn8ajqyvnj9agyn74llb4qgd9kgdcg3gajdfyb2klxx6za8") + (("cecil" "cecil-legacy") "33d50b874fd527118bc361d83de3d494e8bb55e1" + "1p4hl1796ib26ykyf5snl6cj0lx0v7mjh0xqhjw6qdh753nsjyhb") + ("corefx" "74ccd8aa00d7d271191ca3b9c4f818268dc36c28" + "0nm41qdpvj62r8bxnf92m7kimjm1i544ygdqz5a7pgc6zf99as6j" + #:patches ("corefx-mono-pre-5.8.0-patches.patch")) + ("corert" "48dba73801e804e89f00311da99d873f9c550278" + "1zw47jf4cwqmaixylisxi73xf6cap41bwf9vlmpxanzxaqklzsvk") + ("ikdasm" "3aef9cdd6013fc0620a1817f0b11d8fb90ed2e0f" + "078cai33x8c71969iwi7hmbqdfwpicpmam2ag3k2bklpva2vnszv") + (("ikvm-fork" "ikvm") "847e05fced5c9a41ff0f24f1f9d40d5a8a5772c1" + "1fl9bm3lmzf8iqv3x4iqkz9fc54mwdvrxisxg2nvwwcsi4saffpi") + ("linker" "21e445c26c69ac3a2e1441befa02d0bd105ff849" + "1hx3ik0sg70ysc2y8jdjxm2ljql0069i05i8fp1lakx7s7z7bywc") + ("Newtonsoft.Json" "471c3e0803a9f40a0acc8aeceb31de6ff93a52c4" + "0dgngd5hqk6yhlg40kabn6qdnknm32zcx9q6bm2w31csnsk5978s") + (("NuGet.BuildTasks" "nuget-buildtasks") + "8d307472ea214f2b59636431f771894dbcba7258" + "1h1frnj0x8k7b29ic4jisch0vlpmsmghjw554pz277f2nxaidljj") + (("NUnitLite" "nunit-lite") "690603bea98aae69fca9a65130d88591bc6cabee" + "1f845ysjzs3yd9gcyww66dnkx484z5fknb8l0xz74sjmxk2mngwc") + ;; ("roslyn-binaries" "80b86f340b7f6fb7afe84443214e1cbd7ff70620" + ;; "") + ("rx" "b29a4b0fda609e0af33ff54ed13652b6ccf0e05e" + "1n1jwhmsbkcv2d806immcpzkb72rz04xy98myw355a8w5ah25yiv") + ;; ("xunit-binaries" "d4433b0972f40cb3efaa3fbba52869bde5df8fa8" + ;; "") + )) + +(define-public mono-pre-5.8.0 + (let ((commit "d0f51b4e834042cfa593748ada942033b458cc40") + (version "5.4.0.201") + (revision "0")) + (package + (inherit mono-5.4.0) + (version (git-version version revision commit)) + (name "mono") + (source (origin + (method git-fetch) + (uri + (git-reference + (url "https://gitlab.winehq.org/mono/mono.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0az5syk1nn9gd5imkbmpb13qm9q6ibr2d2ksdzpwsarkfyp4ic53")) + (modules '((guix build utils) + (ice-9 string-fun))) + (snippet #~(begin + #$(add-external-repos + mono-pre-5.8.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.4.0) + (replace "mono" mono-5.4.0))) + (arguments + (substitute-keyword-arguments (package-arguments mono-5.4.0) + ((#:phases phases #~%standard-phases) + #~(modify-phases #$phases + (delete 'patch-sub-autogen.sh-shebang)))))))) diff --git a/gnu/packages/patches/corefx-mono-pre-5.8.0-patches.patch b/gnu/packages/patches/corefx-mono-pre-5.8.0-patches.patch new file mode 100644 index 00000000000..04dcc6c5a50 --- /dev/null +++ b/gnu/packages/patches/corefx-mono-pre-5.8.0-patches.patch @@ -0,0 +1,1349 @@ +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 a623bfc0bf..4a742156b9 100644 +--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs ++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/RuntimeBinder.cs +@@ -189,7 +189,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; +@@ -1030,8 +1031,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. + +@@ -1064,8 +1066,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; +@@ -1132,12 +1135,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); + } + +@@ -1146,14 +1152,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 2756538770..99adf488b3 100644 +--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs ++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Conversion.cs +@@ -382,9 +382,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)) + { +@@ -412,8 +413,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 (canCast(expr.Type, dest, flags)) +@@ -546,8 +548,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 +@@ -1387,8 +1390,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: +@@ -1402,8 +1406,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 b55cf07078..9afeaac622 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 159f157f43..4a0e3cb479 100644 +--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs ++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/ExprFactory.cs +@@ -17,33 +17,33 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + Debug.Assert(globalSymbolContext != null); + _globalSymbolContext = globalSymbolContext; + } +- private TypeManager Types => _globalSymbolContext.GetTypes(); ++ private TypeManager Types { get { return _globalSymbolContext.GetTypes(); } } + +- private BSYMMGR GlobalSymbols => _globalSymbolContext.GetGlobalSymbols(); ++ private BSYMMGR GlobalSymbols { get { return _globalSymbolContext.GetGlobalSymbols(); } } + +- public ExprCall CreateCall(EXPRFLAG flags, CType type, Expr arguments, ExprMemberGroup memberGroup, MethWithInst method) => +- new ExprCall(type, flags, arguments, memberGroup, method); ++ public ExprCall CreateCall(EXPRFLAG flags, CType type, Expr arguments, ExprMemberGroup memberGroup, MethWithInst method) ++ { return new ExprCall(type, flags, arguments, memberGroup, method); } + +- public ExprField CreateField(CType type, Expr optionalObject, FieldWithType field, bool isLValue) => +- new ExprField(type, optionalObject, field, isLValue); ++ public ExprField CreateField(CType type, Expr optionalObject, FieldWithType field, bool isLValue) ++ { return new ExprField(type, optionalObject, field, isLValue); } + +- public ExprFuncPtr CreateFunctionPointer(EXPRFLAG flags, CType type, Expr obj, MethWithInst method) => +- new ExprFuncPtr(type, flags, obj, method); ++ public ExprFuncPtr CreateFunctionPointer(EXPRFLAG flags, CType type, Expr obj, MethWithInst method) ++ { return new ExprFuncPtr(type, flags, obj, method); } + +- public ExprArrayInit CreateArrayInit(CType type, Expr arguments, Expr argumentDimensions, int[] dimSizes, int dimSize) => +- new ExprArrayInit(type, arguments, argumentDimensions, dimSizes, dimSize); ++ public ExprArrayInit CreateArrayInit(CType type, Expr arguments, Expr argumentDimensions, int[] dimSizes, int dimSize) ++ { return new ExprArrayInit(type, arguments, argumentDimensions, dimSizes, dimSize); } + +- public ExprProperty CreateProperty(CType type, Expr optionalObject) => +- CreateProperty(type, null, null, CreateMemGroup(optionalObject, new MethPropWithInst()), null, null); ++ public ExprProperty CreateProperty(CType type, Expr optionalObject) ++ { return CreateProperty(type, null, null, CreateMemGroup(optionalObject, new MethPropWithInst()), null, null); } + +- public ExprProperty CreateProperty(CType type, Expr optionalObjectThrough, Expr arguments, ExprMemberGroup memberGroup, PropWithType property, MethWithType setMethod) => +- new ExprProperty(type, optionalObjectThrough, arguments, memberGroup, property, setMethod); ++ public ExprProperty CreateProperty(CType type, Expr optionalObjectThrough, Expr arguments, ExprMemberGroup memberGroup, PropWithType property, MethWithType setMethod) ++ { return new ExprProperty(type, optionalObjectThrough, arguments, memberGroup, property, setMethod); } + +- public ExprEvent CreateEvent(CType type, Expr optionalObject, EventWithType eventWithType) => +- new ExprEvent(type, optionalObject, eventWithType); ++ public ExprEvent CreateEvent(CType type, Expr optionalObject, EventWithType eventWithType) ++ { return new ExprEvent(type, optionalObject, eventWithType); } + +- public ExprMemberGroup CreateMemGroup(EXPRFLAG flags, Name name, TypeArray typeArgs, SYMKIND symKind, CType parentType, MethodOrPropertySymbol memberSymbol, Expr obj, CMemberLookupResults memberLookupResults) => +- new ExprMemberGroup(Types.GetMethGrpType(), flags, name, typeArgs, symKind, parentType, memberSymbol, obj, memberLookupResults); ++ public ExprMemberGroup CreateMemGroup(EXPRFLAG flags, Name name, TypeArray typeArgs, SYMKIND symKind, CType parentType, MethodOrPropertySymbol memberSymbol, Expr obj, CMemberLookupResults memberLookupResults) ++ { return new ExprMemberGroup(Types.GetMethGrpType(), flags, name, typeArgs, symKind, parentType, memberSymbol, obj, memberLookupResults); } + + public ExprMemberGroup CreateMemGroup(Expr obj, MethPropWithInst method) + { +@@ -57,25 +57,25 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + obj, new CMemberLookupResults(GlobalSymbols.AllocParams(1, new[] {type}), name)); + } + +- public ExprUserDefinedConversion CreateUserDefinedConversion(Expr arg, Expr call, MethWithInst method) => +- new ExprUserDefinedConversion(arg, call, method); ++ public ExprUserDefinedConversion CreateUserDefinedConversion(Expr arg, Expr call, MethWithInst method) ++ { return new ExprUserDefinedConversion(arg, call, method); } + + public ExprCast CreateCast(CType type, Expr argument) => CreateCast(0, CreateClass(type), argument); + +- public ExprCast CreateCast(EXPRFLAG flags, ExprClass type, Expr argument) => new ExprCast(flags, type, argument); ++ public ExprCast CreateCast(EXPRFLAG flags, ExprClass type, Expr argument) { return new ExprCast(flags, type, argument); } + +- public ExprReturn CreateReturn(Expr optionalObject) => new ExprReturn(optionalObject); ++ public ExprReturn CreateReturn(Expr optionalObject) { return new ExprReturn(optionalObject); } + +- public ExprLocal CreateLocal(LocalVariableSymbol local) => new ExprLocal(local); ++ public ExprLocal CreateLocal(LocalVariableSymbol local) { return new ExprLocal(local); } + +- public ExprBoundLambda CreateAnonymousMethod(AggregateType delegateType, Scope argumentScope) => +- new ExprBoundLambda(delegateType, argumentScope); ++ public ExprBoundLambda CreateAnonymousMethod(AggregateType delegateType, Scope argumentScope) ++ { return new ExprBoundLambda(delegateType, argumentScope); } + +- public ExprHoistedLocalExpr CreateHoistedLocalInExpression() => +- new ExprHoistedLocalExpr(Types.GetOptPredefAgg(PredefinedType.PT_EXPRESSION).getThisType()); ++ public ExprHoistedLocalExpr CreateHoistedLocalInExpression() ++ { return new ExprHoistedLocalExpr(Types.GetOptPredefAgg(PredefinedType.PT_EXPRESSION).getThisType()); } + +- public ExprMethodInfo CreateMethodInfo(MethPropWithInst mwi) => +- CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs); ++ public ExprMethodInfo CreateMethodInfo(MethPropWithInst mwi) ++ { return CreateMethodInfo(mwi.Meth(), mwi.GetType(), mwi.TypeArgs); } + + public ExprMethodInfo CreateMethodInfo(MethodSymbol method, AggregateType methodType, TypeArray methodParameters) + { +@@ -84,19 +84,19 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + method, methodType, methodParameters); + } + +- public ExprPropertyInfo CreatePropertyInfo(PropertySymbol prop, AggregateType propertyType) => +- new ExprPropertyInfo(Types.GetOptPredefAgg(PredefinedType.PT_PROPERTYINFO).getThisType(), prop, propertyType); ++ public ExprPropertyInfo CreatePropertyInfo(PropertySymbol prop, AggregateType propertyType) ++ { return new ExprPropertyInfo(Types.GetOptPredefAgg(PredefinedType.PT_PROPERTYINFO).getThisType(), prop, propertyType); } + +- public ExprFieldInfo CreateFieldInfo(FieldSymbol field, AggregateType fieldType) => +- new ExprFieldInfo(field, fieldType, Types.GetOptPredefAgg(PredefinedType.PT_FIELDINFO).getThisType()); ++ public ExprFieldInfo CreateFieldInfo(FieldSymbol field, AggregateType fieldType) ++ { return new ExprFieldInfo(field, fieldType, Types.GetOptPredefAgg(PredefinedType.PT_FIELDINFO).getThisType()); } + +- private ExprTypeOf CreateTypeOf(ExprClass sourceType) => +- new ExprTypeOf(Types.GetReqPredefAgg(PredefinedType.PT_TYPE).getThisType(), sourceType); ++ private ExprTypeOf CreateTypeOf(ExprClass sourceType) ++ { return new ExprTypeOf(Types.GetReqPredefAgg(PredefinedType.PT_TYPE).getThisType(), sourceType); } + +- public ExprTypeOf CreateTypeOf(CType sourceType) => CreateTypeOf(CreateClass(sourceType)); ++ public ExprTypeOf CreateTypeOf(CType sourceType) { return CreateTypeOf(CreateClass(sourceType)); } + +- public ExprUserLogicalOp CreateUserLogOp(CType type, Expr trueFalseCall, ExprCall operatorCall) => +- new ExprUserLogicalOp(type, trueFalseCall, operatorCall); ++ public ExprUserLogicalOp CreateUserLogOp(CType type, Expr trueFalseCall, ExprCall operatorCall) ++ { return new ExprUserLogicalOp(type, trueFalseCall, operatorCall); } + + public ExprUserLogicalOp CreateUserLogOpError(CType type, Expr trueFalseCall, ExprCall operatorCall) + { +@@ -105,16 +105,16 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + return rval; + } + +- public ExprConcat CreateConcat(Expr first, Expr second) => new ExprConcat(first, second); ++ public ExprConcat CreateConcat(Expr first, Expr second) { return new ExprConcat(first, second); } + +- public ExprConstant CreateStringConstant(string str) => +- CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_STRING).getThisType(), ConstVal.Get(str)); ++ public ExprConstant CreateStringConstant(string str) ++ { return CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_STRING).getThisType(), ConstVal.Get(str)); } + +- public ExprMultiGet CreateMultiGet(EXPRFLAG flags, CType type, ExprMulti multi) => +- new ExprMultiGet(type, flags, multi); ++ public ExprMultiGet CreateMultiGet(EXPRFLAG flags, CType type, ExprMulti multi) ++ { return new ExprMultiGet(type, flags, multi); } + +- public ExprMulti CreateMulti(EXPRFLAG flags, CType type, Expr left, Expr op) => +- new ExprMulti(type, flags, left, op); ++ public ExprMulti CreateMulti(EXPRFLAG flags, CType type, Expr left, Expr op) ++ { return new ExprMulti(type, flags, left, op); } + + //////////////////////////////////////////////////////////////////////////////// + // +@@ -124,7 +124,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + // + // This returns a null for reference types and an EXPRZEROINIT for all others. + +- public Expr CreateZeroInit(CType type) => CreateZeroInit(CreateClass(type), null, false); ++ public Expr CreateZeroInit(CType type) { return CreateZeroInit(CreateClass(type), null, false); } + + private Expr CreateZeroInit(ExprClass typeExpr, Expr originalConstructorCall, bool isConstructor) + { +@@ -187,15 +187,15 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + return new ExprZeroInit(type, originalConstructorCall, isConstructor, isError); + } + +- public ExprConstant CreateConstant(CType type, ConstVal constVal) => new ExprConstant(type, constVal); ++ public ExprConstant CreateConstant(CType type, ConstVal constVal) { return new ExprConstant(type, constVal); } + +- public ExprConstant CreateIntegerConstant(int x) => +- CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_INT).getThisType(), ConstVal.Get(x)); ++ public ExprConstant CreateIntegerConstant(int x) ++ { return CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_INT).getThisType(), ConstVal.Get(x)); } + +- public ExprConstant CreateBoolConstant(bool b) => +- CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_BOOL).getThisType(), ConstVal.Get(b)); ++ public ExprConstant CreateBoolConstant(bool b) ++ { return CreateConstant(Types.GetReqPredefAgg(PredefinedType.PT_BOOL).getThisType(), ConstVal.Get(b)); } + +- public ExprBlock CreateBlock(ExprStatement pOptionalStatements) => new ExprBlock(pOptionalStatements); ++ public ExprBlock CreateBlock(ExprStatement pOptionalStatements) { return new ExprBlock(pOptionalStatements); } + + public ExprArrayIndex CreateArrayIndex(Expr array, Expr index) + { +@@ -212,11 +212,11 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + return new ExprArrayIndex(type, array, index); + } + +- public ExprBinOp CreateBinop(ExpressionKind exprKind, CType type, Expr left, Expr right) => +- new ExprBinOp(exprKind, type, left, right); ++ public ExprBinOp CreateBinop(ExpressionKind exprKind, CType type, Expr left, Expr right) ++ { return new ExprBinOp(exprKind, type, left, right); } + +- public ExprUnaryOp CreateUnaryOp(ExpressionKind exprKind, CType type, Expr operand) => +- new ExprUnaryOp(exprKind, type, operand); ++ public ExprUnaryOp CreateUnaryOp(ExpressionKind exprKind, CType type, Expr operand) ++ { return new ExprUnaryOp(exprKind, type, operand); } + + public ExprOperator CreateOperator(ExpressionKind exprKind, CType type, Expr arg1, Expr arg2) + { +@@ -228,12 +228,12 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + } + + +- public ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType type, Expr left, Expr right, Expr call, MethPropWithInst userMethod) => +- new ExprBinOp(exprKind, type, left, right, call, userMethod); ++ public ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType type, Expr left, Expr right, Expr call, MethPropWithInst userMethod) ++ { return new ExprBinOp(exprKind, type, left, right, call, userMethod); } + + // The call may be lifted, but we do not mark the outer binop as lifted. +- public ExprUnaryOp CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType type, Expr operand, ExprCall call, MethPropWithInst userMethod) => +- new ExprUnaryOp(exprKind, type, operand, call, userMethod); ++ public ExprUnaryOp CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType type, Expr operand, ExprCall call, MethPropWithInst userMethod) ++ { return new ExprUnaryOp(exprKind, type, operand, call, userMethod); } + + public ExprUnaryOp CreateNeg(EXPRFLAG flags, Expr operand) + { +@@ -246,23 +246,22 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + //////////////////////////////////////////////////////////////////////////////// + // Create a node that evaluates the first, evaluates the second, results in the second. + +- public ExprBinOp CreateSequence(Expr first, Expr second) => +- CreateBinop(ExpressionKind.Sequence, second.Type, first, second); ++ public ExprBinOp CreateSequence(Expr first, Expr second) ++ { return CreateBinop(ExpressionKind.Sequence, second.Type, first, second); } + + //////////////////////////////////////////////////////////////////////////////// + // Create a node that evaluates the first, evaluates the second, results in the first. + +- public ExprBinOp CreateReverseSequence(Expr first, Expr second) => +- CreateBinop(ExpressionKind.SequenceReverse, first.Type, first, second); ++ public ExprBinOp CreateReverseSequence(Expr first, Expr second) ++ { return CreateBinop(ExpressionKind.SequenceReverse, first.Type, first, second); } + +- public ExprAssignment CreateAssignment(Expr left, Expr right) => new ExprAssignment(left, right); ++ public ExprAssignment CreateAssignment(Expr left, Expr right) { return new ExprAssignment(left, right); } + + //////////////////////////////////////////////////////////////////////////////// + +- public ExprNamedArgumentSpecification CreateNamedArgumentSpecification(Name name, Expr value) => +- new ExprNamedArgumentSpecification(name, value); ++ public ExprNamedArgumentSpecification CreateNamedArgumentSpecification(Name name, Expr value) { return new ExprNamedArgumentSpecification(name, value); } + +- public ExprWrap CreateWrap(Expr expression) => new ExprWrap(expression); ++ public ExprWrap CreateWrap(Expr expression) { return new ExprWrap(expression); } + + public ExprBinOp CreateSave(ExprWrap wrap) + { +@@ -272,7 +271,7 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + return expr; + } + +- public ExprConstant CreateNull() => CreateConstant(Types.GetNullType(), default(ConstVal)); ++ public ExprConstant CreateNull() { return CreateConstant(Types.GetNullType(), default(ConstVal)); } + + public void AppendItemToList( + Expr newItem, +@@ -306,14 +305,13 @@ namespace Microsoft.CSharp.RuntimeBinder.Semantics + last = list.OptionalNextListNode; + } + +- public ExprList CreateList(Expr op1, Expr op2) => new ExprList(op1, op2); ++ public ExprList CreateList(Expr op1, Expr op2) { return new ExprList(op1, op2); } + +- public ExprList CreateList(Expr op1, Expr op2, Expr op3) => CreateList(op1, CreateList(op2, op3)); ++ public ExprList CreateList(Expr op1, Expr op2, Expr op3) { return CreateList(op1, CreateList(op2, op3)); } + +- public ExprList CreateList(Expr op1, Expr op2, Expr op3, Expr op4) => +- CreateList(op1, CreateList(op2, CreateList(op3, op4))); ++ public ExprList CreateList(Expr op1, Expr op2, Expr op3, Expr op4) { return CreateList(op1, CreateList(op2, CreateList(op3, op4))); } + +- public ExprClass CreateClass(CType type) => new ExprClass(type); ++ public ExprClass CreateClass(CType type) { return new ExprClass(type); } + } + } + +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 ee75e7b38e..bd7c52f87e 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); +@@ -1570,9 +1574,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; + } + +@@ -1779,8 +1784,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) +@@ -1918,8 +1924,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 +@@ -1941,8 +1948,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 + { +@@ -2009,8 +2017,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; + } +@@ -2364,8 +2373,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 25a8d40341..d17de3977d 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 names = new HashSet(); + 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 c9eb5ae21d..cde533d750 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; +@@ -737,10 +738,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 52d354ac53..f43684690d 100644 +--- a/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs ++++ b/src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MethodTypeInferrer.cs +@@ -1063,10 +1063,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 b23fc44509..7dbe8227ca 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 2abac4cecc..84bc0e1d4c 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)); + } + +@@ -275,11 +276,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 96075b6d38..e0581fd14e 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 +@@ -50,8 +50,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. +@@ -304,8 +305,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); +@@ -576,8 +578,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; +@@ -708,8 +711,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); + } +@@ -831,8 +835,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)) + { +@@ -1174,23 +1179,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.Drawing.Common/src/System/Drawing/Brush.cs b/src/System.Drawing.Common/src/System/Drawing/Brush.cs +index 089069ed64..b202ef7736 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Brush.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Brush.cs +@@ -62,6 +62,6 @@ namespace System.Drawing + } + } + +- ~Brush() => Dispose(false); ++ ~Brush() { Dispose(false); } + } + } +diff --git a/src/System.Drawing.Common/src/System/Drawing/Design/CategoryNameCollection.cs b/src/System.Drawing.Common/src/System/Drawing/Design/CategoryNameCollection.cs +index 065498c3ad..fcc4f8b2b6 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Design/CategoryNameCollection.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Design/CategoryNameCollection.cs +@@ -16,34 +16,34 @@ namespace System.Drawing.Design + /// Initializes a new instance of based on another + /// . + /// +- public CategoryNameCollection(CategoryNameCollection value) => InnerList.AddRange(value); ++ public CategoryNameCollection(CategoryNameCollection value) { InnerList.AddRange(value); } + + /// + /// Initializes a new instance of containing any array of + /// objects. + /// +- public CategoryNameCollection(string[] value) => InnerList.AddRange(value); ++ public CategoryNameCollection(string[] value) { InnerList.AddRange(value); } + + /// + /// Represents the entry at the specified index of the . + /// +- public string this[int index] => ((string)(InnerList[index])); ++ public string this[int index] { get { return ((string)(InnerList[index])); } } + + /// + /// Gets a value indicating whether the contains the specified + /// . + /// +- public bool Contains(string value) => InnerList.Contains(value); ++ public bool Contains(string value) { return InnerList.Contains(value); } + + /// + /// Copies the values to a one-dimensional instance + /// at the specified index. + /// +- public void CopyTo(string[] array, int index) => InnerList.CopyTo(array, index); ++ public void CopyTo(string[] array, int index) { InnerList.CopyTo(array, index); } + + /// + /// Returns the index of a in the . + /// +- public int IndexOf(string value) => InnerList.IndexOf(value); ++ public int IndexOf(string value) { return InnerList.IndexOf(value); } + } + } +diff --git a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/CustomLineCap.cs b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/CustomLineCap.cs +index 152474117d..d9769778c7 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/CustomLineCap.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/CustomLineCap.cs +@@ -38,7 +38,7 @@ namespace System.Drawing.Drawing2D + SetNativeLineCap(nativeLineCap); + } + +- internal CustomLineCap(IntPtr nativeLineCap) => SetNativeLineCap(nativeLineCap); ++ internal CustomLineCap(IntPtr nativeLineCap) { SetNativeLineCap(nativeLineCap); } + + internal void SetNativeLineCap(IntPtr handle) + { +@@ -72,7 +72,7 @@ namespace System.Drawing.Drawing2D + _disposed = true; + } + +- ~CustomLineCap() => Dispose(false); ++ ~CustomLineCap() { Dispose(false); } + + public object Clone() + { +diff --git a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsPathIterator.cs b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsPathIterator.cs +index cb9c34c62a..3b552f1baf 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsPathIterator.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsPathIterator.cs +@@ -58,7 +58,7 @@ namespace System.Drawing.Drawing2D + } + } + +- ~GraphicsPathIterator() => Dispose(false); ++ ~GraphicsPathIterator() { Dispose(false); } + + public int NextSubpath(out int startIndex, out int endIndex, out bool isClosed) + { +diff --git a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsState.cs b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsState.cs +index c7d086756e..61de948b2d 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsState.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/GraphicsState.cs +@@ -8,7 +8,7 @@ namespace System.Drawing.Drawing2D + { + internal int nativeState; + +- internal GraphicsState(int nativeState) => this.nativeState = nativeState; ++ internal GraphicsState(int nativeState) { this.nativeState = nativeState; } + } + } + +diff --git a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/RegionData.cs b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/RegionData.cs +index 596b8622eb..dfa2446c87 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Drawing2D/RegionData.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Drawing2D/RegionData.cs +@@ -6,7 +6,7 @@ namespace System.Drawing.Drawing2D + { + public sealed class RegionData + { +- internal RegionData(byte[] data) => Data = data; ++ internal RegionData(byte[] data) { Data = data; } + + public byte[] Data { get; set; } + } +diff --git a/src/System.Drawing.Common/src/System/Drawing/Text/FontCollection.cs b/src/System.Drawing.Common/src/System/Drawing/Text/FontCollection.cs +index df2ac5c8c2..a451dc621d 100644 +--- a/src/System.Drawing.Common/src/System/Drawing/Text/FontCollection.cs ++++ b/src/System.Drawing.Common/src/System/Drawing/Text/FontCollection.cs +@@ -14,7 +14,7 @@ namespace System.Drawing.Text + { + internal IntPtr _nativeFontCollection; + +- internal FontCollection() => _nativeFontCollection = IntPtr.Zero; ++ internal FontCollection() { _nativeFontCollection = IntPtr.Zero; } + + /// + /// Disposes of this +@@ -58,6 +58,6 @@ namespace System.Drawing.Text + } + } + +- ~FontCollection() => Dispose(false); ++ ~FontCollection() { Dispose(false); } + } + } +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 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.Linq/src/System/Linq/Reverse.cs b/src/System.Linq/src/System/Linq/Reverse.cs +index e68a4f42ee..a6352779b0 100644 +--- a/src/System.Linq/src/System/Linq/Reverse.cs ++++ b/src/System.Linq/src/System/Linq/Reverse.cs +@@ -103,19 +103,24 @@ namespace System.Linq + { + if (onlyIfCheap) + { +- switch (_source) ++ if (_source is IIListProvider) + { +- case IIListProvider listProv: +- return listProv.GetCount(onlyIfCheap: true); +- +- case ICollection colT: +- return colT.Count; +- +- case ICollection col: +- return col.Count; +- +- default: +- return -1; ++ IIListProvider listProv = (IIListProvider)_source; ++ return listProv.GetCount(onlyIfCheap: true); ++ } ++ else if (_source is ICollection) ++ { ++ ICollection colT = (ICollection) _source; ++ return colT.Count; ++ } ++ else if (_source is ICollection) ++ { ++ ICollection col = (ICollection) _source; ++ return col.Count; ++ } ++ else ++ { ++ return -1; + } + } + +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); + } + } -- Efraim Flashner אפרים פלשנר GPG key = A28B F40C 3E55 1372 662D 14F7 41AA E7DC CA3D 8351 Confidentiality cannot be guaranteed on emails sent or received unencrypted