{"id":410048,"date":"2024-06-29T21:08:05","date_gmt":"2024-06-29T21:08:05","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=410048"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=410048","title":{"rendered":"Unicorns break into RTS: analyzing the OpenRA source code<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n
\"image1.png\"<\/div>\n

This article is about the check of the OpenRA project using the static PVS-Studio analyzer. What is OpenRA? It is an open source game engine designed to create real-time strategies. The article describes the analysis process, project features, and warnings that PVS-Studio has issued. And, of course, here we will discuss some features of the analyzer that made the project checking process more comfortable.
<\/a> <\/p>\n

OpenRA<\/h2>\n

<\/p>\n

\"image2.png\"<\/div>\n

The project chosen for the check is a game engine for RTS in the style of games such as Command & Conquer: Red Alert. More information can be found on the website<\/a>. The source code is written in C# and is available for viewing and using in the repository<\/a>.<\/p>\n

There were 3 reasons for choosing OpenRA for a review. First, it seems to be of interest to many people. In any case, this applies to the inhabitants of GitHub, since the repository has reached the rating of more than 8 thousand stars. Second, the OpenRA code base contains 1285 files. Usually this amount is quite enough to hope to find interesting warnings in them. And third\u2026 Game engines are cool.<\/p>\n

Redundant warnings<\/h2>\n

I analyzed OpenRA using PVS-Studio and at first was encouraged by the results:<\/p>\n

\"image3.png\"<\/div>\n

I decided that among so many High level warnings, I could definitely find a whole lot of different sapid errors. Therefore, based on them, I would write the coolest and most intriguing article \ud83d\ude42 But no such luck!<\/p>\n

One glance at the warnings and everything clicked into place. 1,277 of the 1,306 High level warnings were related to the V3144<\/a> diagnostic. It gives messages of the type «This file is marked with a copyleft license, which requires you to open the derived source code». This diagnostic is described in more detail here<\/a>.<\/p>\n

Obviously, I wasn’t interested in warnings of such kind, as OpenRA is already an open source project. Therefore, they had to be hidden so that they didn’t interfere with viewing the rest of the log. Since I used the Visual Studio plugin, it was easy to do so. I just had to right-click on one of the V3144<\/a> warnings and select «Hide all V3144<\/a> errors» in the opening menu.<\/p>\n

\"image5.png\"<\/div>\n

You can also choose which warnings will be displayed in the log by going to the «Detectable Errors (C#)» section in the analyzer options.<\/p>\n

\"image7.png\"<\/div>\n

To go to them using the plugin for Visual Studio 2019, click on the top menu Extensions->PVS-Studio->Options.<\/p>\n

Check results<\/h2>\n

After the V3144<\/a> warnings were filtered out, there were significantly fewer warnings in the log:<\/p>\n

\"image8.png\"<\/div>\n

Nevertheless, I managed to find worthy ones among them.<\/p>\n

Meaningless conditions<\/h3>\n

Quite a few positives pointed to unnecessary checks. This may indicate an error, because people usually don’t write this code intentionally. However, in OpenRA, it often looks as if these unnecessary conditions were added on purpose. For example:<\/p>\n

public virtual void Tick() {   ....    Active = !Disabled && Instances.Any(i => !i.IsTraitPaused);   if (!Active)     return;    if (Active)   {     ....   } }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3022<\/a> Expression ‘Active’ is always true. SupportPowerManager.cs 206<\/p>\n
  PVS-Studio quite rightly notes that the second check is meaningless, because if Active<\/i> is false<\/i>, it won’t execute. It might be an error, but I think it was written intentionally. What for? Well, why not?<\/p>\n
  Perhaps, what we have here is a temporary solution, which was supposed to be refined later. In such cases, it is quite convenient that the analyzer will remind a developer of such shortcomings.<\/p>\n
  Let’s look at another just-in-case check:<\/p>\n
Pair<string, bool>[] MakeComponents(string text) {   ....    if (highlightStart > 0 && highlightEnd > highlightStart)  \/\/ <=   {     if (highlightStart > 0)                                 \/\/ <=     {       \/\/ Normal line segment before highlight       var lineNormal = line.Substring(0, highlightStart);       components.Add(Pair.New(lineNormal, false));     }        \/\/ Highlight line segment     var lineHighlight = line.Substring(       highlightStart + 1,        highlightEnd - highlightStart \u2013 1     );     components.Add(Pair.New(lineHighlight, true));     line = line.Substring(highlightEnd + 1);   }   else   {     \/\/ Final normal line segment     components.Add(Pair.New(line, false));     break;   }   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3022<\/a> Expression ‘highlightStart > 0’ is always true. LabelWithHighlightWidget.cs 54<\/p>\n
  Again, it is obvious that re-checking is completely pointless. The value of highlightStart<\/i> is checked twice, right in neighbouring lines. A mistake? It is possible that in one of the conditions wrong variables are selected for checking. Anyway, it’s hard to say for sure what’s going on here. One thing is definitely clear \u2014 the code should be reviewed and corrected. Or there should be an explanation if additional check is still needed for some reason.<\/p>\n
  Here is another similar case:<\/p>\n
public static void ButtonPrompt(....) {   ....   var cancelButton = prompt.GetOrNull<ButtonWidget>(     \"CANCEL_BUTTON\"   );   ....    if (onCancel != null && cancelButton != null)   {     cancelButton.Visible = true;     cancelButton.Bounds.Y += headerHeight;     cancelButton.OnClick = () =>     {       Ui.CloseWindow();       if (onCancel != null)         onCancel();     };      if (!string.IsNullOrEmpty(cancelText) && cancelButton != null)       cancelButton.GetText = () => cancelText;   }   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3063<\/a> A part of conditional expression is always true if it is evaluated: cancelButton != null. ConfirmationDialogs.cs 78<\/p>\n
  cancelButton<\/i> can be null<\/i> indeed, because the value returned by the GetOrNull<\/i> method is written to this variable. However, it stands to reason that by no means will cancelButton<\/i> turn to null<\/i> in the body of the conditional operator. Yet the check is still present. If you don’t pay attention to the external condition, you happen to be in a very strange situation. First the variable properties are accessed, and then the developer decides to make sure if there is null<\/i> or not.<\/p>\n
  At first, I assumed that the project might be using some specific logic related to overloading the «==» operator. In my opinion, implementing something like this in a project for reference types is a controversial idea. Not to mention the fact that unusual behavior makes it harder for other developers to understand the code. At the same time, it is difficult for me to imagine a situation where you can’t do without such tricks. Although it is likely that in some specific case this would be a convenient solution.<\/p>\n
  In the Unity game engine, for example, the «==<\/i>» operator is redefined for the UnityEngine.Object<\/i> class. The official documentation available by the link<\/a> shows that comparing instances of this class<\/i> with null doesn’t work as usual. Well, the developer probably had reasons for implementing this unusual logic.<\/p>\n
  I didn’t find anything like this in OpenRA :). So if there is any meaning in the null<\/i> checks discussed earlier, it is something else.<\/p>\n
  PVS-Studio managed to find a few more similar cases, but there is no need to list them all here. Well, it’s a bit boring to watch the same triggers. Fortunately (or not), the analyzer was able to find other oddities.<\/p>\n
Unreachable code<\/h3>\n
  <\/p>\n
void IResolveOrder.ResolveOrder(Actor self, Order order) {   ....   if (!order.Queued || currentTransform == null)     return;      if (!order.Queued && currentTransform.NextActivity != null)     currentTransform.NextActivity.Cancel(self);    .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3022<\/a> Expression ‘!order.Queued && currentTransform.NextActivity != null’ is always false. TransformsIntoTransforms.cs 44<\/p>\n
  Once again, we have a pointless check here. However, unlike the previous ones, this is not just an extra condition, but a real unreachable code. The always true<\/i> checks above didn’t actually affect the program’s performance. You can remove them from the code, or you can leave them \u2013 nothing will change.<\/p>\n
  Whereas in this case, the strange check results in the fact that a part of the code isn’t executed. At the same time, it is difficult for me to guess what changes should be made here as an amendment. In the simplest and most preferable scenario, unreachable code simply shouldn’t be executed. Then there is no mistake. However, I doubt that the programmer deliberately wrote the line just for the sake of beauty.<\/p>\n
Uninitialized variable in the constructor<\/h3>\n
  <\/p>\n
public class CursorSequence {   ....   public readonly ISpriteFrame[] Frames;    public CursorSequence(     FrameCache cache,      string name,      string cursorSrc,      string palette,      MiniYaml info   )   {     var d = info.ToDictionary();      Start = Exts.ParseIntegerInvariant(d[\"Start\"].Value);     Palette = palette;     Name = name;      if (       (d.ContainsKey(\"Length\") && d[\"Length\"].Value == \"*\") ||        (d.ContainsKey(\"End\") && d[\"End\"].Value == \"*\")     )        Length = Frames.Length - Start;     else if (d.ContainsKey(\"Length\"))       Length = Exts.ParseIntegerInvariant(d[\"Length\"].Value);     else if (d.ContainsKey(\"End\"))       Length = Exts.ParseIntegerInvariant(d[\"End\"].Value) - Start;     else       Length = 1;      Frames = cache[cursorSrc]       .Skip(Start)       .Take(Length)       .ToArray();      ....   } }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3128<\/a> The ‘Frames’ field is used before it is initialized in constructor. CursorSequence.cs 35<\/p>\n
  A nasty case. An attempt to get the Length<\/i> property value from an uninitialized variable will inevitably result in the NullReferenceException<\/i>. In a normal situation, it is unlikely that such an error would have gone unnoticed \u2013 yet the inability to create an instance of the class is easily detected. But here the exception will only be thrown if the condition<\/p>\n
(d.ContainsKey(\"Length\") && d[\"Length\"].Value == \"*\") ||  (d.ContainsKey(\"End\") && d[\"End\"].Value == \"*\")<\/code><\/pre>\n
  is true. <\/p>\n
  It is difficult to judge how to correct the code so that everything is fine. I can only assume that the function should look something like this:<\/p>\n
public CursorSequence(....) {   var d = info.ToDictionary();    Start = Exts.ParseIntegerInvariant(d[\"Start\"].Value);   Palette = palette;   Name = name;   ISpriteFrame[] currentCache = cache[cursorSrc];        if (     (d.ContainsKey(\"Length\") && d[\"Length\"].Value == \"*\") ||      (d.ContainsKey(\"End\") && d[\"End\"].Value == \"*\")   )      Length = currentCache.Length - Start;   else if (d.ContainsKey(\"Length\"))     Length = Exts.ParseIntegerInvariant(d[\"Length\"].Value);   else if (d.ContainsKey(\"End\"))     Length = Exts.ParseIntegerInvariant(d[\"End\"].Value) - Start;   else     Length = 1;    Frames = currentCache     .Skip(Start)     .Take(Length)     .ToArray();    .... }<\/code><\/pre>\n
  In this version, the stated problem is absent, but only the developer can tell to what extent it corresponds to the original idea.<\/p>\n
Potential typo<\/h3>\n
  <\/p>\n
public void Resize(int width, int height) {   var oldMapTiles = Tiles;   var oldMapResources = Resources;   var oldMapHeight = Height;   var oldMapRamp = Ramp;   var newSize = new Size(width, height);    ....   Tiles = CellLayer.Resize(oldMapTiles, newSize, oldMapTiles[MPos.Zero]);   Resources = CellLayer.Resize(     oldMapResources,     newSize,     oldMapResources[MPos.Zero]   );   Height = CellLayer.Resize(oldMapHeight, newSize, oldMapHeight[MPos.Zero]);   Ramp = CellLayer.Resize(oldMapRamp, newSize, oldMapHeight[MPos.Zero]);     .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3127<\/a> Two similar code fragments were found. Perhaps, this is a typo and ‘oldMapRamp’ variable should be used instead of ‘oldMapHeight’ Map.cs 964<\/p>\n
  The analyzer detected a suspicious fragment associated with passing arguments to the function. Let’s look at the calls separately:<\/p>\n
CellLayer.Resize(oldMapTiles,     newSize, oldMapTiles[MPos.Zero]); CellLayer.Resize(oldMapResources, newSize, oldMapResources[MPos.Zero]); CellLayer.Resize(oldMapHeight,    newSize, oldMapHeight[MPos.Zero]); CellLayer.Resize(oldMapRamp,      newSize, oldMapHeight[MPos.Zero]);<\/code><\/pre>\n
  Oddly enough, the last call passes oldMapHeight<\/i>, not oldMapRamp<\/i>. Of course, not all such cases are erroneous. It is quite possible that everything is written correctly here. But you will probably agree that this place looks unusual. I’m inclined to believe that there is an error for sure.<\/p>\n
  Note by a colleague Andrey Karpov<\/a>. I don’t see anything strange in this code :). It’s a classic  last line mistake<\/a>!<\/i><\/p>\n
  If there is no error, then one should add some explanation. After all, if a snippet looks like an error, then someone will want to fix it. <\/p>\n
True, true and nothing but true<\/h3>\n
  The project revealed very peculiar methods, the return value of which is of the bool<\/i> type. Their uniqueness lies in the fact that they return true<\/i> under any conditions. For example:<\/p>\n
static bool State(   S server,    Connection conn,    Session.Client client,    string s ) {   var state = Session.ClientState.Invalid;   if (!Enum<Session.ClientState>.TryParse(s, false, out state))   {     server.SendOrderTo(conn, \"Message\", \"Malformed state command\");     return true;   }    client.State = state;    Log.Write(     \"server\",      \"Player @{0} is {1}\",     conn.Socket.RemoteEndPoint,      client.State   );    server.SyncLobbyClients();    CheckAutoStart(server);    return true; }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3009<\/a> It’s odd that this method always returns one and the same value of ‘true’. LobbyCommands.cs 123<\/p>\n
  Is everything OK in this code? Is there an error? It looks extremely strange. Why haven’t the developer used void<\/i>?<\/p>\n
  It’s not surprising that the analyzer finds such a place strange, but we still have to admit that the programmer actually had a reason to write this way. Which one? <\/p>\n
  I decided to check where this method is called and whether its returned always true<\/i> value is used. It turned out that there is only one reference to it in the same class \u2013 in the commandHandlers<\/i> dictionary, which has the type<\/p>\n
IDictionary<string, Func<S, Connection, Session.Client, string, bool>><\/code><\/pre>\n
  During the initialization, the following values are added to it<\/p>\n
{\"state\", State}, {\"startgame\", StartGame}, {\"slot\", Slot}, {\"allow_spectators\", AllowSpectators}<\/code><\/pre>\n
  and others.<\/p>\n
  Here we have a rare (I’d like to think so) case of static typing that creates problems for us. After all, to make a dictionary in which the values are functions with different signatures\u2026 is at least challenging. commandHandlers<\/i> is only used in the InterpretCommand<\/i> method:<\/p>\n
public bool InterpretCommand(   S server, Connection conn, Session.Client client, string cmd ) {   if (     server == null ||      conn == null ||      client == null ||      !ValidateCommand(server, conn, client, cmd)   )  return false;    var cmdName = cmd.Split(' ').First();   var cmdValue = cmd.Split(' ').Skip(1).JoinWith(\" \");    Func<S, Connection, Session.Client, string, bool> a;   if (!commandHandlers.TryGetValue(cmdName, out a))     return false;    return a(server, conn, client, cmdValue); }<\/code><\/pre>\n
  Apparently, the developer intended to have the universal possibility to match strings to certain operations. I think that the chosen method is not the only one, but it is not so easy to offer something more convenient\/correct in such a situation. Especially if you don’t use dynamic<\/i> or something like that. If you have any ideas about this, please leave comments. I would be interested to look at various solutions to this problem:).<\/p>\n
  It turns out that warnings associated with always true<\/i> methods in this class are most likely false. And yet\u2026 What disquiets me here is this »most likely» \ud83d\ude42 One has to really be careful and not miss an actual error among these positives. <\/p>\n
  All such warnings should be first carefully checked, and then marked as false if necessary. You can simply do it. You should leave a special comment in the place indicated by the analyzer:<\/p>\n
static bool State(....) \/\/-V3009<\/code><\/pre>\n
  There is another way: you can select the warnings that need to be marked as false, and click on «Mark selected messages as False Alarms» in the context menu.<\/p>\n
\"image10.png\"<\/div>\n
  You can learn more about this topic in the documentation<\/a>.<\/p>\n
Extra check for null?<\/h3>\n
  <\/p>\n
static bool SyncLobby(....) {   if (!client.IsAdmin)   {     server.SendOrderTo(conn, \"Message\", \"Only the host can set lobby info\");     return true;   }    var lobbyInfo = Session.Deserialize(s);    if (lobbyInfo == null)                    \/\/ <=   {     server.SendOrderTo(conn, \"Message\", \"Invalid Lobby Info Sent\");     return true;   }    server.LobbyInfo = lobbyInfo;    server.SyncLobbyInfo();    return true; }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3022<\/a> Expression ‘lobbyInfo == null’ is always false. LobbyCommands.cs 851<\/p>\n
  Here we have another method that always returns true<\/i>. However, this time we are looking at a different type of a warning. We have to pore over such places with all diligence, as there is no guarantee that we deal with redundant code. But first things first.<\/p>\n
  The Deserialize<\/i> method never returns null<\/i> \u2013 you can easily see this by looking at its code:<\/p>\n
public static Session Deserialize(string data) {   try   {     var session = new Session();     ....     return session;   }   catch (YamlException)   {     throw new YamlException(....);   }   catch (InvalidOperationException)   {     throw new YamlException(....);   } }<\/code><\/pre>\n
  For ease of reading, I have shortened the source code of the method. You can see it in full by clicking on the link<\/a>. Or take my word for it that the session<\/i> variable doesn’t turn to null<\/i> under any circumstances.<\/p>\n
  So what do we see at the bottom part? Deserialize<\/i> doesn’t return null<\/i>, and if something goes wrong, it throws exceptions. The developer who wrote the null<\/i> check after the call was of a different mind, apparently. Most likely, in an exceptional situation, the SyncLobby<\/i> method should execute the code that is currently being executed\u2026 Actually, it is never executed, because lobbyInfo<\/i> is never null<\/i>:<\/p>\n
if (lobbyInfo == null) {   server.SendOrderTo(conn, \"Message\", \"Invalid Lobby Info Sent\");   return true; }<\/code><\/pre>\n
  I believe that instead of this «extra» check, the author still needs to use try<\/i>—catch<\/i>. Or try another tack and write, let’s say, TryDeserialize<\/i>, which in case of an exceptional situation will return null<\/i>.<\/p>\n
Possible NullReferenceException<\/h3>\n
  <\/p>\n
public ConnectionSwitchModLogic(....) {   ....   var logo = panel.GetOrNull<RGBASpriteWidget>(\"MOD_ICON\");   if (logo != null)   {     logo.GetSprite = () =>     {       ....     };   }    if (logo != null && mod.Icon == null)                    \/\/ <=   {     \/\/ Hide the logo and center just the text     if (title != null)     title.Bounds.X = logo.Bounds.Left;      if (version != null)       version.Bounds.X = logo.Bounds.X;     width -= logo.Bounds.Width;   }   else   {     \/\/ Add an equal logo margin on the right of the text     width += logo.Bounds.Width;                           \/\/ <=   }   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3125<\/a> The ‘logo’ object was used after it was verified against null. Check lines: 236, 222. ConnectionLogic.cs 236<\/p>\n
  As for this case, I’m sure as hell there is an error. We are definitely not looking at «extra» checks, because the GetOrNull<\/i> method can indeed return a null reference. What happens if logo<\/i> is null<\/i>? Accessing the Bounds<\/i> property will result in an exception, which was clearly not part of the developer’s plans.<\/p>\n
  Perhaps, the fragment needs to be rewritten in the following way:<\/p>\n
if (logo != null) {   if (mod.Icon == null)   {     \/\/ Hide the logo and center just the text     if (title != null)     title.Bounds.X = logo.Bounds.Left;      if (version != null)       version.Bounds.X = logo.Bounds.X;     width -= logo.Bounds.Width;   }   else   {     \/\/ Add an equal logo margin on the right of the text     width += logo.Bounds.Width;   } }<\/code><\/pre>\n
  This option is quite simple for comprehension, although the additional nesting doesn’t look too great. As a more comprehensive solution, one could use the null-conditional operator:<\/p>\n
\/\/ Add an equal logo margin on the right of the text width += logo?.Bounds.Width ?? 0; \/\/ <=<\/code><\/pre>\n
  By the way, the first version looks more preferable to me. It is easy to read it and triggers no questions. But some developers appreciate brevity quite highly, so I also decided to cite the second version as well :).<\/p>\n
Maybe, OrDefault after all?<\/h3>\n
  <\/p>\n
public MapEditorLogic(....) {   var editorViewport = widget.Get<EditorViewportControllerWidget>(\"MAP_EDITOR\");    var gridButton = widget.GetOrNull<ButtonWidget>(\"GRID_BUTTON\");   var terrainGeometryTrait = world.WorldActor.Trait<TerrainGeometryOverlay>();    if (gridButton != null && terrainGeometryTrait != null) \/\/ <=   {     ....   }    var copypasteButton = widget.GetOrNull<ButtonWidget>(\"COPYPASTE_BUTTON\");   if (copypasteButton != null)   {     ....   }    var copyFilterDropdown = widget.Get<DropDownButtonWidget>(....);   copyFilterDropdown.OnMouseDown = _ =>   {     copyFilterDropdown.RemovePanel();     copyFilterDropdown.AttachPanel(CreateCategoriesPanel());   };    var coordinateLabel = widget.GetOrNull<LabelWidget>(\"COORDINATE_LABEL\");   if (coordinateLabel != null)   {     ....   }    .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3063<\/a> A part of conditional expression is always true if it is evaluated: terrainGeometryTrait != null. MapEditorLogic.cs 35<\/p>\n
  Let’s delve into this fragment. Note that each time the GetOrNull<\/i> method of the Widget<\/i> class is used, a null<\/i> equality check is performed. However, if Get<\/i> is used, there is no check. This is logical \u2013 the Get<\/i> method doesn’t return null<\/i>:<\/p>\n
public T Get<T>(string id) where T : Widget {   var t = GetOrNull<T>(id);   if (t == null)     throw new InvalidOperationException(....);   return t; }<\/code><\/pre>\n
  If the element is not found, an exception is thrown \u2013 this is reasonable behavior. At the same time, the logical option would be to check the values returned by the GetOrNull<\/i> method for equality to the null reference.<\/p>\n
  In the code above, the value returned by the Trait<\/i> method is checked for null<\/i>. Actually it is inside the Trait<\/i> method where Get<\/i> of the TraitDictionary<\/i> class is called:<\/p>\n
public T Trait<T>() {   return World.TraitDict.Get<T>(this); }<\/code><\/pre>\n
  Can it be that this Get<\/i> behaves differently from the one we discussed earlier? Well, the classes are different. Let’s check it out:<\/p>\n
public T Get<T>(Actor actor) {   CheckDestroyed(actor);   return InnerGet<T>().Get(actor); }<\/code><\/pre>\n
  The InnerGet<\/i> method returns an instance of TraitContainer<T><\/i>. The Get<\/i> implementation in this class is very similar to Get<\/i> of the Widget<\/i> class:<\/p>\n
public T Get(Actor actor) {   var result = GetOrDefault(actor);   if (result == null)     throw new InvalidOperationException(....);   return result; }<\/code><\/pre>\n
  The main similarity is that null<\/i> is never returned here either. If something goes wrong, an InvalidOperationException<\/i> is similarly thrown. Therefore, the Trait<\/i> method behaves the same way.<\/p>\n
  Yes, there may just be an extra check that doesn’t affect anything. Except that it looks strange, but you can’t say that this code will confuse a reader much. But if the check is needed indeed, then in some cases an exception will be thrown unexpectedly. It is sad.<\/p>\n
  So in this fragment it seems more appropriate to call, for example, TraitOrNull<\/i>. However, there is no such method:). But there is TraitOrDefault<\/i>, which is the equivalent of GetOrNull<\/i> for this case.<\/p>\n
  There is another similar case related to the Get<\/i> method:<\/p>\n
public AssetBrowserLogic(....) {   ....   frameSlider = panel.Get<SliderWidget>(\"FRAME_SLIDER\");   if (frameSlider != null)   {     ....   }   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3022<\/a> Expression ‘frameSlider != null’ is always true. AssetBrowserLogic.cs 128<\/p>\n
  The same as in the code considered earlier, there is something wrong here. Either the check is really unnecessary, or one still needs to call GetOrNull<\/i> instead of Get<\/i>.<\/p>\n
Lost assignment<\/h3>\n
  <\/p>\n
public SpawnSelectorTooltipLogic(....) {   ....   var textWidth = ownerFont.Measure(labelText).X;   if (textWidth != cachedWidth)   {     label.Bounds.Width = textWidth;     widget.Bounds.Width = 2 * label.Bounds.X + textWidth; \/\/ <=   }    widget.Bounds.Width = Math.Max(                         \/\/ <=     teamWidth + 2 * labelMargin,      label.Bounds.Right + labelMargin   );   team.Bounds.Width = widget.Bounds.Width;   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3008<\/a> The ‘widget.Bounds.Width’ variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 78, 75. SpawnSelectorTooltipLogic.cs 78<\/p>\n
  It seems that if the textWidth != cachedWidth<\/i> condition is true, widget.Bounds.Width<\/i> must be written to a specific value for this case. However, an assignment made below, regardless of whether this condition is true, makes the string<\/p>\n
widget.Bounds.Width = 2 * label.Bounds.X + textWidth;<\/code><\/pre>\n
  pointless. It is likely that the author just forgot to write else<\/i> here:<\/p>\n
if (textWidth != cachedWidth) {   label.Bounds.Width = textWidth;   widget.Bounds.Width = 2 * label.Bounds.X + textWidth; } else {   widget.Bounds.Width = Math.Max(     teamWidth + 2 * labelMargin,     label.Bounds.Right + labelMargin   ); }<\/code><\/pre>\n
  <\/p>\n
Checking the default value<\/h3>\n
  <\/p>\n
public void DisguiseAs(Actor target) {   ....   var tooltip = target.TraitsImplementing<ITooltip>().FirstOrDefault();   AsPlayer = tooltip.Owner;   AsActor = target.Info;   AsTooltipInfo = tooltip.TooltipInfo;   .... }<\/code><\/pre>\n
  Analyzer warning<\/b>: V3146<\/a> Possible null dereference of ‘tooltip’. The ‘FirstOrDefault’ can return default null value. Disguise.cs 192<\/p>\n
  When is FirstOrDefault<\/i> usually used instead of First<\/i>? If the selection is empty, First<\/i> throws an InvalidOperationException<\/i>. FirstOrDefault<\/i> doesn’t throw an exception, but returns null<\/i> for the reference type. <\/p>\n
  The ITooltip<\/i> interface implements various classes in the project. Thus, if target.TraitsImplementing<ITooltip>()<\/i> returns an empty selection, null<\/i> is written to tooltip<\/i>. Accessing the properties of this object, which is executed next, will result in a NullReferenceException<\/i>.<\/p>\n
  In cases where the developer is sure that the selection won’t be empty, it is better to use First<\/i>. If one isn’t sure, it’s worth checking the value returned by FirstOrDefault.<\/i> It is rather strange that we don’t see it here. After all, the values returned by the GetOrNull<\/i> method mentioned earlier were always checked. Why didn’t they do it here?<\/p>\n
  Who knows?.. All right, the developer will answer these questions for sure. In the end, it is the code author who will be fixing it \ud83d\ude42<\/p>\n
Conclusion<\/h2>\n
  OpenRA somehow turned out to be a project that was nice and interesting to scan. The developers did a lot of work and didn’t forget that the source code should be easy to view. Of course, we did find some\u2026 controversies, but one can’t simply do without them \ud83d\ude42<\/p>\n
  At the same time, even with all the effort, alas, developers remain people. Some of the considered warnings are extremely difficult to notice without using the analyzer. It is sometimes difficult to find an error even immediately after writing it. Needless to say, how hard it is to search for error after a long time.<\/p>\n
  Obviously, it is much better to detect an error than its consequences. To do this, you can spend hours rechecking a huge number of new sources manually. Well, and have a bit of a look at the old ones \u2014 what if there is an oversight there? Yes, reviews are really useful, but if you have to view a large amount of code, then you stop noticing some things over time. And it takes a lot of time and effort.<\/p>\n
\"image11.png\"<\/div>\n
  Static analysis is just a convenient addition to other methods of checking the quality of source code, such as code review. PVS-Studio will find «simple» (and sometimes tricky) errors instead of a developer, allowing people to focus on more serious issues.<\/p>\n
  Yes, the analyzer sometimes gives false positives and is not able to find all the errors. But with it you will save a lot of time and nerves. Yes, it is not perfect and sometimes makes mistakes itself. However, in general, PVS-Studio makes the development process much easier, more enjoyable, and even (unexpectedly!) cheaper.<\/p>\n
  In fact, you don’t need to take my word for it \u2014 it’s much better to make sure that the above is true yourself. You can use the link<\/a> to download the analyzer and get a trial key. What could be simpler?<\/p>\n
  Well, that’s it for this time. Thanks for your attention! I wish you clean code and an empty error log!<\/p><\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/514964\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
\n
\n
\n
\n
\"image1.png\"<\/div>\n
  This article is about the check of the OpenRA project using the static PVS-Studio analyzer. What is OpenRA? It is an open source game engine designed to create real-time strategies. The article describes the analysis process, project features, and warnings that PVS-Studio has issued. And, of course, here we will discuss some features of the analyzer that made the project checking process more comfortable.  <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-410048","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/410048","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=410048"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/410048\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=410048"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=410048"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=410048"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}