Use pattern matching (#596)

Author: gpetrou

Src/DLR

@@ -92,10 +92,9 @@ private MSAst.Expression AssignComplex(MSAst.Expression right) {
         private MSAst.Expression AssignOne() {
             Debug.Assert(_left.Length == 1);
 
-            SequenceExpression seLeft = _left[0] as SequenceExpression;
-            SequenceExpression seRight = _right as SequenceExpression;
-
-            if (seLeft != null && seRight != null && seLeft.Items.Count == seRight.Items.Count) {
+            if (_left[0] is SequenceExpression seLeft &&
+                _right is SequenceExpression seRight &&
+                seLeft.Items.Count == seRight.Items.Count) {
                 int cnt = seLeft.Items.Count;
 
                 // a, b = 1, 2, or [a,b] = 1,2 - not something like a, b = range(2)

Src/IronPython/Compiler/Ast/AssignmentStatement.cs

@@ -70,10 +70,7 @@ private bool NeedComparisonTransformation() {
             return IsComparison() && IsComparison(_right);
         }
 
-        public static bool IsComparison(Expression expression) {
-            BinaryExpression be = expression as BinaryExpression;
-            return be != null && be.IsComparison();
-        }
+        public static bool IsComparison(Expression expression) => expression is BinaryExpression be && be.IsComparison();
 
         // This is a compound comparison operator like: a < b < c.
         // That's represented as binary operators, but it's not the same as (a<b) < c, so we do special transformations.

Src/IronPython/Compiler/Ast/BinaryExpression.cs

@@ -299,8 +299,7 @@ private string FindSelfNames() {
             if (stmts == null) return "";
 
             foreach (Statement stmt in stmts.Statements) {
-                FunctionDefinition def = stmt as FunctionDefinition;
-                if (def != null && def.Name == "__init__") {
+                if (stmt is FunctionDefinition def && def.Name == "__init__") {
                     return string.Join(",", SelfNameFinder.FindNames(def));
                 }
             }
@@ -353,8 +352,7 @@ public override bool Walk(FunctionDefinition node) {
 
             public override bool Walk(AssignmentStatement node) {
                 foreach (Expression lhs in node.Left) {
-                    MemberExpression me = lhs as MemberExpression;
-                    if (me != null) {
+                    if (lhs is MemberExpression me) {
                         if (IsSelfReference(me.Target)) {
                             _names[me.Name] = true;
                         }

Src/IronPython/Compiler/Ast/ClassDefinition.cs

@@ -47,8 +47,7 @@ public override void Walk(PythonWalker walker) {
 
         public override string Documentation {
             get {
-                ConstantExpression ce = _expression as ConstantExpression;
-                if (ce != null) {
+                if (_expression is ConstantExpression ce) {
                     return ce.Value as string;
                 }
                 return null;

Src/IronPython/Compiler/Ast/ExpressionStatement.cs

@@ -169,8 +169,7 @@ internal override bool CanThrow {
                 }
 
                 // most constants (int, float, long, etc...) will throw here
-                ConstantExpression ce = _list as ConstantExpression;
-                if (ce != null) {
+                if (_list is ConstantExpression ce) {
                     if (ce.Value is string) {
                         return false;
                     }

Src/IronPython/Compiler/Ast/ForStatement.cs

@@ -123,8 +123,7 @@ public override MSAst.Expression Reduce() {
         }
 
         private object GetLevel() {
-            RelativeModuleName rmn = _root as RelativeModuleName;
-            if (rmn != null) {
+            if (_root is RelativeModuleName rmn) {
                 return rmn.DotCount;
             }
 

Src/IronPython/Compiler/Ast/FromImportStatement.cs

@@ -451,14 +451,12 @@ private static void CompileAssignment(LightCompiler compiler, MSAst.Expression v
                 return;
             }
 
-            MSAst.ParameterExpression functionValueParam = variable as MSAst.ParameterExpression;
-            if (functionValueParam != null) {
+            if (variable is MSAst.ParameterExpression functionValueParam) {
                 instructions.EmitStoreLocal(compiler.Locals.GetLocalIndex(functionValueParam));
                 return;
             }
 
-            var globalVar = variable as PythonGlobalVariableExpression;
-            if (globalVar != null) {
+            if (variable is PythonGlobalVariableExpression globalVar) {
                 instructions.Emit(new PythonSetGlobalInstruction(globalVar.Global));
                 instructions.EmitPop();
                 return;
@@ -575,8 +573,7 @@ private LightLambdaExpression CreateFunctionLambda() {
             List<MSAst.Expression> init = new List<MSAst.Expression>();
 
             foreach (var param in _parameters) {
-                IPythonVariableExpression pyVar = GetVariableExpression(param.PythonVariable) as IPythonVariableExpression;
-                if (pyVar != null) {
+                if (GetVariableExpression(param.PythonVariable) is IPythonVariableExpression pyVar) {
                     var varInit = pyVar.Create();
                     if (varInit != null) {
                         init.Add(varInit);
@@ -848,8 +845,7 @@ internal class ArbitraryGlobalsVisitor : MSAst.ExpressionVisitor {
             protected override MSAst.Expression VisitExtension(MSAst.Expression node) {
 
                 // update the global get/set/raw gets variables
-                var global = node as PythonGlobalVariableExpression;
-                if (global != null) {
+                if (node is PythonGlobalVariableExpression global) {
                     return new LookupGlobalVariable(
                         PythonAst._globalContext,
                         global.Variable.Name,
@@ -858,8 +854,7 @@ protected override MSAst.Expression VisitExtension(MSAst.Expression node) {
                 }
 
                 // set covers sets and deletes
-                var setGlobal = node as PythonSetGlobalVariableExpression;
-                if (setGlobal != null) {
+                if (node is PythonSetGlobalVariableExpression setGlobal) {
                     if (setGlobal.Value == PythonGlobalVariableExpression.Uninitialized) {
                         return new LookupGlobalVariable(
                             PythonAst._globalContext,

Src/IronPython/Compiler/Ast/FunctionDefinition.cs

@@ -41,13 +41,11 @@ public override MSAst.Expression Reduce() {
         }
 
         private MSAst.Expression[] GetActionArgumentsForGetOrDelete() {
-            TupleExpression te = _index as TupleExpression;
-            if (te != null && te.IsExpandable) {
+            if (_index is TupleExpression te && te.IsExpandable) {
                 return ArrayUtils.Insert(_target, te.Items);
             }
 
-            SliceExpression se = _index as SliceExpression;
-            if (se != null) {
+            if (_index is SliceExpression se) {
                 if (se.StepProvided) {
                     return new[] { 
                         _target,

Src/IronPython/Compiler/Ast/IndexExpression.cs

@@ -312,11 +312,9 @@ internal static MSAst.Expression TransformMaybeSingleLineSuite(Statement body, S
         }
 
         internal static MSAst.Expression RemoveDebugInfo(int prevStart, MSAst.Expression res) {
-            MSAst.BlockExpression block = res as MSAst.BlockExpression;
-            if (block != null && block.Expressions.Count > 0) {
-                MSAst.DebugInfoExpression dbgInfo = block.Expressions[0] as MSAst.DebugInfoExpression;
+            if (res is BlockExpression block && block.Expressions.Count > 0) {
                 // body on the same line as an if, don't generate a 2nd sequence point
-                if (dbgInfo != null && dbgInfo.StartLine == prevStart) {
+                if (block.Expressions[0] is DebugInfoExpression dbgInfo && dbgInfo.StartLine == prevStart) {
                     // we remove the debug info based upon how it's generated in DebugStatement.AddDebugInfo which is
                     // the helper method which adds the debug info.
                     if (block.Type == typeof(void)) {
@@ -351,8 +349,7 @@ internal static MSAst.Expression RemoveFrame(MSAst.Expression expression) {
 
         class FramedCodeVisitor : ExpressionVisitor {
             public override MSAst.Expression Visit(MSAst.Expression node) {
-                FramedCodeExpression framedCode = node as FramedCodeExpression;
-                if (framedCode != null) {
+                if (node is FramedCodeExpression framedCode) {
                     return framedCode.Body;
                 }
                 return base.Visit(node);
@@ -443,17 +440,15 @@ internal MSAst.Expression MakeAssignment(MSAst.ParameterExpression variable, MSA
             Debug.Assert(expression != null);
             Debug.Assert(value != null);
 
-            IPythonVariableExpression pyGlobal = expression as IPythonVariableExpression;
-            if (pyGlobal != null) {
+            if (expression is IPythonVariableExpression pyGlobal) {
                 return pyGlobal.Assign(value);
             }
 
             return Ast.Assign(expression, value);
         }
 
         internal static MSAst.Expression/*!*/ Delete(MSAst.Expression/*!*/ expression) {
-            IPythonVariableExpression pyGlobal = expression as IPythonVariableExpression;
-            if (pyGlobal != null) {
+            if (expression is IPythonVariableExpression pyGlobal) {
                 return pyGlobal.Delete();
             }