C#: Simplify null checks with pattern matching, ??, and ?:

tamasvajk · tamasvajk · commit e208f3d21d67 · 2020-10-13T13:27:46.000+02:00
diff --git a/csharp/autobuilder/Semmle.Autobuild.Shared/MsBuildRule.cs b/csharp/autobuilder/Semmle.Autobuild.Shared/MsBuildRule.cs
@@ -98,15 +98,9 @@ BuildScript GetNugetRestoreScript() =>
 
                 command.Argument("/p:UseSharedCompilation=false");
 
-                string target = builder.Options.MsBuildTarget != null
-                                       ? builder.Options.MsBuildTarget
-                                       : "rebuild";
-                string? platform = builder.Options.MsBuildPlatform != null
-                                         ? builder.Options.MsBuildPlatform
-                                         : projectOrSolution is ISolution s1 ? s1.DefaultPlatformName : null;
-                string? configuration = builder.Options.MsBuildConfiguration != null
-                                              ? builder.Options.MsBuildConfiguration
-                                              : projectOrSolution is ISolution s2 ? s2.DefaultConfigurationName : null;
+                string target = builder.Options.MsBuildTarget ?? "rebuild";
+                string? platform = builder.Options.MsBuildPlatform ?? (projectOrSolution is ISolution s1 ? s1.DefaultPlatformName : null);
+                string? configuration = builder.Options.MsBuildConfiguration ?? (projectOrSolution is ISolution s2 ? s2.DefaultConfigurationName : null);
 
                 command.Argument("/t:" + target);
                 if (platform != null)
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Context.cs b/csharp/extractor/Semmle.Extraction.CIL/Context.cs
@@ -113,7 +113,7 @@ public Entities.Type ErrorType
         /// <returns>The debugging information, or null if the information could not be located.</returns>
         public PDB.IMethod? GetMethodDebugInformation(MethodDefinitionHandle handle)
         {
-            return pdb == null ? null : pdb.GetMethod(handle.ToDebugInformationHandle());
+            return pdb?.GetMethod(handle.ToDebugInformationHandle());
         }
     }
 
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Method.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Method.cs
@@ -409,9 +409,9 @@ public MemberReferenceMethod(GenericContext gc, MemberReferenceHandle handle) :
 
             parent = (GenericContext)cx.CreateGeneric(gc, mr.Parent);
 
-            var parentMethod = parent as Method;
-
-            var declType = parentMethod is null ? parent as Type : parentMethod.DeclaringType;
+            var declType = parent is Method parentMethod
+                ? parentMethod.DeclaringType
+                : parent as Type;
 
             if (declType is null)
                 throw new InternalError("Parent context of method is not a type");
diff --git a/csharp/extractor/Semmle.Extraction.CIL/PDB/NativePdbReader.cs b/csharp/extractor/Semmle.Extraction.CIL/PDB/NativePdbReader.cs
@@ -39,8 +39,7 @@ public Document(ISymUnmanagedDocument doc)
 
             public override bool Equals(object? obj)
             {
-                var otherDoc = obj as Document;
-                return otherDoc != null && Path.Equals(otherDoc.Path);
+                return obj is Document otherDoc && Path.Equals(otherDoc.Path);
             }
 
             public override int GetHashCode() => Path.GetHashCode();
diff --git a/csharp/extractor/Semmle.Extraction.CIL/PDB/PdbReader.cs b/csharp/extractor/Semmle.Extraction.CIL/PDB/PdbReader.cs
@@ -56,9 +56,7 @@ public override string ToString()
 
         public override bool Equals(object? obj)
         {
-            var otherLocation = obj as Location;
-
-            return otherLocation != null &&
+            return obj is Location otherLocation &&
                 File.Equals(otherLocation.File) &&
                 StartLine == otherLocation.StartLine &&
                 StartColumn == otherLocation.StartColumn &&
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Analyser.cs b/csharp/extractor/Semmle.Extraction.CSharp/Analyser.cs
@@ -290,9 +290,8 @@ void DoAnalyseAssembly(PortableExecutableReference r)
                     // in c to be garbage collected.
                     Compilation c = compilation.Clone();
 
-                    var assembly = c.GetAssemblyOrModuleSymbol(r) as IAssemblySymbol;
 
-                    if (assembly != null)
+                    if (c.GetAssemblyOrModuleSymbol(r) is IAssemblySymbol assembly)
                     {
                         var cx = extractor.CreateContext(c, trapWriter, new AssemblyScope(assembly, assemblyPath, false), AddAssemblyTrapPrefix);
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Accessor.cs
@@ -16,8 +16,7 @@ protected Accessor(Context cx, IMethodSymbol init)
         public static IPropertySymbol GetPropertySymbol(IMethodSymbol symbol)
         {
             // Usually, the property/indexer can be fetched from the associated symbol
-            var prop = symbol.AssociatedSymbol as IPropertySymbol;
-            if (prop != null)
+            if (symbol.AssociatedSymbol is IPropertySymbol prop)
                 return prop;
 
             // But for properties/indexers that implement explicit interfaces, Roslyn
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Constructor.cs
@@ -36,7 +36,7 @@ protected override void ExtractInitializers(TextWriter trapFile)
             if (!IsSourceDeclaration) return;
 
             var syntax = Syntax;
-            var initializer = syntax == null ? null : syntax.Initializer;
+            var initializer = syntax?.Initializer;
 
             if (initializer == null) return;
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expression.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expression.cs
@@ -212,10 +212,11 @@ protected static ExpressionSyntax FindConditionalQualifier(ExpressionSyntax node
         {
             for (SyntaxNode n = node; n != null; n = n.Parent)
             {
-                var conditionalAccess = n.Parent as ConditionalAccessExpressionSyntax;
-
-                if (conditionalAccess != null && conditionalAccess.WhenNotNull == n)
+                if (n.Parent is ConditionalAccessExpressionSyntax conditionalAccess &&
+                    conditionalAccess.WhenNotNull == n)
+                {
                     return conditionalAccess.Expression;
+                }
             }
 
             throw new InternalError(node, "Unable to locate a ConditionalAccessExpression");
@@ -434,8 +435,7 @@ public AnnotatedTypeSymbol ExpressionType
                 // Clearly a bug.
                 if (type.Symbol?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)
                 {
-                    var arrayCreation = Node as ArrayCreationExpressionSyntax;
-                    if (arrayCreation != null)
+                    if (Node is ArrayCreationExpressionSyntax arrayCreation)
                     {
                         var elementType = Context.GetType(arrayCreation.Type.ElementType);
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ElementAccess.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ElementAccess.cs
@@ -39,8 +39,7 @@ protected override void PopulateExpression(TextWriter trapFile)
 
                 var symbolInfo = cx.GetSymbolInfo(base.Syntax);
 
-                var indexer = symbolInfo.Symbol as IPropertySymbol;
-                if (indexer != null)
+                if (symbolInfo.Symbol is IPropertySymbol indexer)
                 {
                     trapFile.expr_access(this, Indexer.Create(cx, indexer));
                 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ImplicitCast.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/ImplicitCast.cs
@@ -50,8 +50,9 @@ public static Expression Create(ExpressionNodeInfo info)
 
                 if (convertedToDelegate)
                 {
-                    var objectCreation = info.Parent as ExplicitObjectCreation;
-                    bool isExplicitConversion = objectCreation != null && objectCreation.Kind == ExprKind.EXPLICIT_DELEGATE_CREATION;
+                    bool isExplicitConversion =
+                        info.Parent is ExplicitObjectCreation objectCreation &&
+                        objectCreation.Kind == ExprKind.EXPLICIT_DELEGATE_CREATION;
 
                     if (!isExplicitConversion)
                     {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Initializer.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Initializer.cs
@@ -64,9 +64,7 @@ protected override void PopulateExpression(TextWriter trapFile)
 
             foreach (var init in Syntax.Expressions)
             {
-                var assignment = init as AssignmentExpressionSyntax;
-
-                if (assignment != null)
+                if (init is AssignmentExpressionSyntax assignment)
                 {
                     var assignmentInfo = new ExpressionNodeInfo(cx, init, this, child++).SetKind(ExprKind.SIMPLE_ASSIGN);
                     var assignmentEntity = new Expression(assignmentInfo);
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Invocation.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Invocation.cs
@@ -53,12 +53,11 @@ protected override void PopulateExpression(TextWriter trapFile)
                     if (target != null && !target.IsStatic)
                     {
                         // Implicit `this` qualifier; add explicitly
-                        var callingMethod = cx.GetModel(Syntax).GetEnclosingSymbol(Location.symbol.SourceSpan.Start) as IMethodSymbol;
 
-                        if (callingMethod == null)
-                            cx.ModelError(Syntax, "Couldn't determine implicit this type");
-                        else
+                        if (cx.GetModel(Syntax).GetEnclosingSymbol(Location.symbol.SourceSpan.Start) is IMethodSymbol callingMethod)
                             This.CreateImplicit(cx, Entities.Type.Create(cx, callingMethod.ContainingType), Location, this, child++);
+                        else
+                            cx.ModelError(Syntax, "Couldn't determine implicit this type");
                     }
                     else
                     {
@@ -156,8 +155,8 @@ node.Expression is IdentifierNameSyntax &&
 
         static bool IsLocalFunctionInvocation(ExpressionNodeInfo info)
         {
-            var target = info.SymbolInfo.Symbol as IMethodSymbol;
-            return target != null && target.MethodKind == MethodKind.LocalFunction;
+            return info.SymbolInfo.Symbol is IMethodSymbol target &&
+                target.MethodKind == MethodKind.LocalFunction;
         }
 
         static ExprKind GetKind(ExpressionNodeInfo info)
@@ -175,8 +174,7 @@ static bool IsNameof(InvocationExpressionSyntax syntax)
         {
             // Odd that this is not a separate expression type.
             // Maybe it will be in the future.
-            var id = syntax.Expression as IdentifierNameSyntax;
-            return id != null && id.Identifier.Text == "nameof";
+            return syntax.Expression is IdentifierNameSyntax id && id.Identifier.Text == "nameof";
         }
     }
 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/VariableDeclaration.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/VariableDeclaration.cs
@@ -157,8 +157,7 @@ public static VariableDeclaration CreateDeclarator(Context cx, VariableDeclarato
                     cx.TrapWriter.Writer.expr_access(access, localVar);
                 }
 
-                var decl = d.Parent as VariableDeclarationSyntax;
-                if (decl != null)
+                if (d.Parent is VariableDeclarationSyntax decl)
                     TypeMention.Create(cx, decl.Type, ret, type);
             });
             return ret;
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/LocalVariable.cs
@@ -48,8 +48,7 @@ public static LocalVariable Create(Context cx, ISymbol local)
 
         void DefineConstantValue(TextWriter trapFile)
         {
-            var local = symbol as ILocalSymbol;
-            if (local != null && local.HasConstantValue)
+            if (symbol is ILocalSymbol local && local.HasConstantValue)
             {
                 trapFile.constant_value(this, Expression.ValueAsString(local.ConstantValue));
             }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs
@@ -34,8 +34,9 @@ protected virtual int Ordinal
                 // omit the "this" parameter, so the parameters are
                 // actually numbered from 1.
                 // This is to be consistent from the original (unreduced) extension method.
-                var method = symbol.ContainingSymbol as IMethodSymbol;
-                bool isReducedExtension = method != null && method.MethodKind == MethodKind.ReducedExtension;
+                bool isReducedExtension =
+                    symbol.ContainingSymbol is IMethodSymbol method &&
+                    method.MethodKind == MethodKind.ReducedExtension;
                 return symbol.Ordinal + (isReducedExtension ? 1 : 0);
             }
         }
@@ -57,8 +58,8 @@ Kind ParamKind
 
                         if (Ordinal == 0)
                         {
-                            var method = symbol.ContainingSymbol as IMethodSymbol;
-                            if (method != null && method.IsExtensionMethod) return Kind.This;
+                            if (symbol.ContainingSymbol is IMethodSymbol method && method.IsExtensionMethod)
+                                return Kind.This;
                         }
                         return Kind.None;
                 }
@@ -160,7 +161,7 @@ public override void Populate(TextWriter trapFile)
         static EqualsValueClauseSyntax GetParameterDefaultValue(IParameterSymbol parameter)
         {
             var syntax = parameter.DeclaringSyntaxReferences.Select(@ref => @ref.GetSyntax()).OfType<ParameterSyntax>().FirstOrDefault();
-            return syntax != null ? syntax.Default : null;
+            return syntax?.Default;
         }
 
         class ParameterFactory : ICachedEntityFactory<(IParameterSymbol, IEntity, Parameter), Parameter>
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs
@@ -61,7 +61,8 @@ bool IsImplicitOperator(out ITypeSymbol containingType)
             if (containingType != null)
             {
                 var containingNamedType = containingType as INamedTypeSymbol;
-                return containingNamedType == null || !containingNamedType.GetMembers(symbol.Name).Contains(symbol);
+                return containingNamedType == null ||
+                    !containingNamedType.GetMembers(symbol.Name).Contains(symbol);
             }
 
             var pointerType = symbol.Parameters.Select(p => p.Type).OfType<IPointerTypeSymbol>().FirstOrDefault();
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Entities/UsingDirective.cs b/csharp/extractor/Semmle.Extraction.CSharp/Entities/UsingDirective.cs
@@ -26,20 +26,18 @@ protected override void Populate(TextWriter trapFile)
             if (Node.StaticKeyword.Kind() == SyntaxKind.None)
             {
                 // A normal using
-                var namespaceSymbol = info.Symbol as INamespaceSymbol;
-
-                if (namespaceSymbol == null)
-                {
-                    cx.Extractor.MissingNamespace(Node.Name.ToFullString(), cx.FromSource);
-                    cx.ModelError(Node, "Namespace not found");
-                    return;
-                }
-                else
+                if (info.Symbol is INamespaceSymbol namespaceSymbol)
                 {
                     var ns = Namespace.Create(cx, namespaceSymbol);
                     trapFile.using_namespace_directives(this, ns);
                     trapFile.using_directive_location(this, cx.Create(ReportingLocation));
                 }
+                else
+                {
+                    cx.Extractor.MissingNamespace(Node.Name.ToFullString(), cx.FromSource);
+                    cx.ModelError(Node, "Namespace not found");
+                    return;
+                }
             }
             else
             {
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs b/csharp/extractor/Semmle.Extraction.CSharp/SymbolExtensions.cs
@@ -46,11 +46,10 @@ public static ITypeSymbol DisambiguateType(this ITypeSymbol type)
              * The conservative option would be to resolve all error types as null.
              */
 
-            var errorType = type as IErrorTypeSymbol;
 
-            return errorType != null && errorType.CandidateSymbols.Any() ?
-                errorType.CandidateSymbols.First() as ITypeSymbol :
-                type;
+            return type is IErrorTypeSymbol errorType && errorType.CandidateSymbols.Any()
+                ? errorType.CandidateSymbols.First() as ITypeSymbol
+                : type;
         }
 
         /// <summary>
@@ -489,11 +488,9 @@ public static bool IsSourceDeclaration(this IMethodSymbol method) =>
         /// </summary>
         public static bool IsSourceDeclaration(this IParameterSymbol parameter)
         {
-            var method = parameter.ContainingSymbol as IMethodSymbol;
-            if (method != null)
+            if (parameter.ContainingSymbol is IMethodSymbol method)
                 return method.IsSourceDeclaration();
-            var property = parameter.ContainingSymbol as IPropertySymbol;
-            if (property != null && property.IsIndexer)
+            if (parameter.ContainingSymbol is IPropertySymbol property && property.IsIndexer)
                 return property.IsSourceDeclaration();
             return true;
         }
diff --git a/csharp/extractor/Semmle.Extraction/Entities/Assembly.cs b/csharp/extractor/Semmle.Extraction/Entities/Assembly.cs
@@ -43,11 +43,10 @@ public override int GetHashCode() =>
 
         public override bool Equals(object? obj)
         {
-            var other = obj as Assembly;
-            if (other == null || other.GetType() != typeof(Assembly))
-                return false;
+            if (obj is Assembly other && other.GetType() == typeof(Assembly))
+                return Equals(symbol, other.symbol);
 
-            return Equals(symbol, other.symbol);
+            return false;
         }
 
         public new static Location Create(Context cx, Microsoft.CodeAnalysis.Location loc) => AssemblyConstructorFactory.Instance.CreateEntity(cx, loc, loc);
diff --git a/csharp/extractor/Semmle.Util/LineCounter.cs b/csharp/extractor/Semmle.Util/LineCounter.cs
@@ -33,8 +33,10 @@ public sealed class LineCounts
 
         public override bool Equals(object? other)
         {
-            var rhs = other as LineCounts;
-            return rhs != null && Total == rhs.Total && Code == rhs.Code && Comment == rhs.Comment;
+            return other is LineCounts rhs &&
+                Total == rhs.Total &&
+                Code == rhs.Code &&
+                Comment == rhs.Comment;
         }
 
         public override int GetHashCode()

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ public Entities.Type ErrorType`
`113`	`113`	`/// <returns>The debugging information, or null if the information could not be located.</returns>`
`114`	`114`	`public PDB.IMethod? GetMethodDebugInformation(MethodDefinitionHandle handle)`
`115`	`115`	`{`
`116`		`- return pdb == null ? null : pdb.GetMethod(handle.ToDebugInformationHandle());`
	`116`	`+ return pdb?.GetMethod(handle.ToDebugInformationHandle());`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,7 @@ public Document(ISymUnmanagedDocument doc)`
`39`	`39`
`40`	`40`	`public override bool Equals(object? obj)`
`41`	`41`	`{`
`42`		`- var otherDoc = obj as Document;`
`43`		`- return otherDoc != null && Path.Equals(otherDoc.Path);`
	`42`	`+ return obj is Document otherDoc && Path.Equals(otherDoc.Path);`
`44`	`43`	`}`
`45`	`44`
`46`	`45`	`public override int GetHashCode() => Path.GetHashCode();`
Original file line number	Diff line number	Diff line change
`@@ -290,9 +290,8 @@ void DoAnalyseAssembly(PortableExecutableReference r)`
`290`	`290`	`// in c to be garbage collected.`
`291`	`291`	`Compilation c = compilation.Clone();`
`292`	`292`
`293`		`- var assembly = c.GetAssemblyOrModuleSymbol(r) as IAssemblySymbol;`
`294`	`293`
`295`		`- if (assembly != null)`
	`294`	`+ if (c.GetAssemblyOrModuleSymbol(r) is IAssemblySymbol assembly)`
`296`	`295`	`{`
`297`	`296`	`var cx = extractor.CreateContext(c, trapWriter, new AssemblyScope(assembly, assemblyPath, false), AddAssemblyTrapPrefix);`
`298`	`297`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,7 @@ protected Accessor(Context cx, IMethodSymbol init)`
`16`	`16`	`public static IPropertySymbol GetPropertySymbol(IMethodSymbol symbol)`
`17`	`17`	`{`
`18`	`18`	`// Usually, the property/indexer can be fetched from the associated symbol`
`19`		`- var prop = symbol.AssociatedSymbol as IPropertySymbol;`
`20`		`- if (prop != null)`
	`19`	`+ if (symbol.AssociatedSymbol is IPropertySymbol prop)`
`21`	`20`	`return prop;`
`22`	`21`
`23`	`22`	`// But for properties/indexers that implement explicit interfaces, Roslyn`
Original file line number	Diff line number	Diff line change
`@@ -212,10 +212,11 @@ protected static ExpressionSyntax FindConditionalQualifier(ExpressionSyntax node`
`212`	`212`	`{`
`213`	`213`	`for (SyntaxNode n = node; n != null; n = n.Parent)`
`214`	`214`	`{`
`215`		`- var conditionalAccess = n.Parent as ConditionalAccessExpressionSyntax;`
`216`		`-`
`217`		`- if (conditionalAccess != null && conditionalAccess.WhenNotNull == n)`
	`215`	`+ if (n.Parent is ConditionalAccessExpressionSyntax conditionalAccess &&`
	`216`	`+ conditionalAccess.WhenNotNull == n)`
	`217`	`+ {`
`218`	`218`	`return conditionalAccess.Expression;`
	`219`	`+ }`
`219`	`220`	`}`
`220`	`221`
`221`	`222`	`throw new InternalError(node, "Unable to locate a ConditionalAccessExpression");`
`@@ -434,8 +435,7 @@ public AnnotatedTypeSymbol ExpressionType`
`434`	`435`	`// Clearly a bug.`
`435`	`436`	`if (type.Symbol?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)`
`436`	`437`	`{`
`437`		`- var arrayCreation = Node as ArrayCreationExpressionSyntax;`
`438`		`- if (arrayCreation != null)`
	`438`	`+ if (Node is ArrayCreationExpressionSyntax arrayCreation)`
`439`	`439`	`{`
`440`	`440`	`var elementType = Context.GetType(arrayCreation.Type.ElementType);`
`441`	`441`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,7 @@ protected override void PopulateExpression(TextWriter trapFile)`
`39`	`39`
`40`	`40`	`var symbolInfo = cx.GetSymbolInfo(base.Syntax);`
`41`	`41`
`42`		`- var indexer = symbolInfo.Symbol as IPropertySymbol;`
`43`		`- if (indexer != null)`
	`42`	`+ if (symbolInfo.Symbol is IPropertySymbol indexer)`
`44`	`43`	`{`
`45`	`44`	`trapFile.expr_access(this, Indexer.Create(cx, indexer));`
`46`	`45`	`}`