Checks: Add Ada Checks ADA95_5.5.1, ADA95_5.5.6

Author: kennethctdmn

CodeCheck/Published Standards/Ada 95/ADA95_5.5.1/check.upy

@@ -0,0 +1,107 @@
+ERR1 = "Use 'Range or the subtype name of the range instead of Type'First .. Type'Last"
+
+
+def ids():
+    return ("ADA95_5.5.1",)
+
+
+def name(id):
+    return {
+        "ADA95_5.5.1": "Published Standards/Ada 95/5.5.1 Range Values",
+    }[id]
+
+
+def tags(id):
+    return {
+        "ADA95_5.5.1": [
+            "Language: Ada",
+            "Standard: Ada 95",
+            "Expressions",
+        ],
+    }.get(id, [])
+
+
+def detailed_description(id):
+    return {
+        "ADA95_5.5.1": """
+<p><b>Guideline</b></p>
+<p>&#8226; Use <code>'First</code> or <code>'Last</code> instead of numeric literals to represent the first or last values of a range.</p>
+<p>&#8226; Use <code>'Range</code> or the subtype name of the range instead of <code>'First .. 'Last</code>.</p>
+
+<p><b>Example</b></p>
+<pre><code language="Ada">type Temperature      is range All_Time_Low .. All_Time_High;
+type Weather_Stations is range            1 ..  Max_Stations;
+Current_Temperature : Temperature := 60;
+Offset              : Temperature;
+...
+for I in Weather_Stations loop
+   Offset := Current_Temperature - Temperature'First;
+   ...
+end loop;
+</code></pre>
+
+<p><b>Rationale</b></p>
+<p>In the example above, it is better to use <code>Weather_Stations</code> in the <code>for</code> loop than to use <code>Weather_Stations'First .. Weather_Stations'Last</code> or <code>1 .. Max_Stations</code> because it is clearer, less error-prone, and less dependent on the definition of the type <code>Weather_Stations</code>. Similarly, it is better to use <code>Temperature'First</code> in the offset calculation than to use <code>All_Time_Low</code> because the code will still be correct if the definition of the subtype <code>Temperature</code> is changed. This enhances program reliability.</p>
+
+<p><b>Caution</b></p>
+<p>When you implicitly specify ranges and attributes like this, be careful that you use the correct subtype name. It is easy to refer to a very large range without realizing it. For example, given the declarations:</p>
+<pre><code language="Ada">type    Large_Range is new Integer;
+subtype Small_Range is Large_Range range 1 .. 10;
+type Large_Array is array (Large_Range) of Integer;
+type Small_Array is array (Small_Range) of Integer;
+</code></pre>
+<p>then the first declaration below works fine, but the second one is probably an accident and raises an exception on most machines because it is requesting a huge array (indexed from the smallest integer to the largest one):</p>
+<pre><code language="Ada">Array_1 : Small_Array;
+Array_2 : Large_Array;
+</code></pre>
+
+<p><b>Developer's Note</b></p>
+<p>Guideline 1 (use <code>'First</code>/<code>'Last</code> instead of numeric literals) is not automated: determining whether a numeric literal could be replaced by a named attribute requires full type inference across the type hierarchy, which cannot be determined statically.</p>
+""",
+    }[id]
+
+
+def test_entity(file):
+    return file.kind().check("Ada File")
+
+
+def check(check, file):
+    lex = file.lexer(lookup_ents=False).first()
+
+    while lex:
+        if lex.token() == "Identifier":
+            type_name = lex.text()
+
+            next_lex = lex.next(True, True)
+            if not (next_lex and next_lex.text() == "'"):
+                lex = lex.next(True, True)
+                continue
+
+            next_lex = next_lex.next(True, True)
+            if not (next_lex and next_lex.text().lower() == "first"):
+                lex = lex.next(True, True)
+                continue
+
+            next_lex = next_lex.next(True, True)
+            if not (next_lex and next_lex.text() == ".."):
+                lex = lex.next(True, True)
+                continue
+
+            next_lex = next_lex.next(True, True)
+            if not (next_lex and next_lex.text() == type_name):
+                lex = lex.next(True, True)
+                continue
+
+            next_lex = next_lex.next(True, True)
+            if not (next_lex and next_lex.text() == "'"):
+                lex = lex.next(True, True)
+                continue
+
+            next_lex = next_lex.next(True, True)
+            if not (next_lex and next_lex.text().lower() == "last"):
+                lex = lex.next(True, True)
+                continue
+
+            check.violation(None, file, lex.line_begin(), lex.column_begin(), ERR1)
+
+        lex = lex.next(True, True)

CodeCheck/Published Standards/Ada 95/ADA95_5.5.1/test.adb

@@ -0,0 +1,78 @@
+package body Test_5_5_1 is
+
+   procedure Do_Work is
+      type Temp_Values is array (Temperature) of Integer;
+      Vals   : Temp_Values := (others => 0);
+      Slice  : Temp_Values;
+      X      : Integer := 0;
+      I      : Temperature := Temperature'First;
+   begin
+      -- Violation: for loop using T'First .. T'Last
+      for J in Temperature'First .. Temperature'Last loop -- UndCC_Violation
+         X := Integer(J);
+      end loop;
+
+      -- Valid: for loop using 'Range
+      for J in Temperature'Range loop -- UndCC_Valid
+         X := Integer(J);
+      end loop;
+
+      -- Valid: for loop using type name
+      for J in Temperature loop -- UndCC_Valid
+         X := Integer(J);
+      end loop;
+
+      -- Violation: reverse for loop using T'First .. T'Last
+      for J in reverse Temperature'First .. Temperature'Last loop -- UndCC_Violation
+         X := Integer(J);
+      end loop;
+
+      -- Violation: membership test using T'First .. T'Last
+      if I in Temperature'First .. Temperature'Last then -- UndCC_Violation
+         null;
+      end if;
+
+      -- Valid: membership test using 'Range
+      if I in Temperature'Range then -- UndCC_Valid
+         null;
+      end if;
+
+      -- Violation: array slice using T'First .. T'Last
+      Slice := Vals(Temperature'First .. Temperature'Last); -- UndCC_Violation
+
+      -- Valid: array slice using 'Range
+      Slice := Vals(Temperature'Range); -- UndCC_Valid
+
+      -- Violation: multi-line T'First .. T'Last (whitespace is skipped)
+      for J in
+         Temperature'First .. -- UndCC_Violation
+         Temperature'Last loop
+         null;
+      end loop;
+
+      -- Violation: Color enum range
+      for C in Color'First .. Color'Last loop -- UndCC_Violation
+         null;
+      end loop;
+
+      -- Valid: Color using 'Range
+      for C in Color'Range loop -- UndCC_Valid
+         null;
+      end loop;
+
+      -- Valid: type-converted bounds are a different pattern (Integer range, not Temperature)
+      if X in Integer(Temperature'First) .. Integer(Temperature'Last) then -- UndCC_Valid
+         null;
+      end if;
+
+      -- Valid: only 'First used standalone (no .. follows)
+      X := Integer(Temperature'First); -- UndCC_Valid
+
+      -- Valid: only 'Last used standalone
+      X := Integer(Temperature'Last); -- UndCC_Valid
+
+      -- Valid: 'Pred attribute (not 'First/'Last, should not trigger)
+      X := Integer(Color'Pos(Color'Pred(Color'Last))); -- UndCC_Valid
+   end Do_Work;
+
+end Test_5_5_1;

CodeCheck/Published Standards/Ada 95/ADA95_5.5.1/test.ads

@@ -0,0 +1,49 @@
+package Test_5_5_1 is
+
+   type Temperature is range -50 .. 150;
+   type Color is (Red, Green, Blue);
+   type Index is range 1 .. 100;
+
+   -- Violation: T'First .. T'Last in subtype constraint
+   subtype Temp_Full is Temperature range Temperature'First .. Temperature'Last; -- UndCC_Violation
+
+   -- Valid: using 'Range
+   subtype Temp_Range is Temperature range Temperature'Range; -- UndCC_Valid
+
+   -- Valid: using type name directly
+   subtype Temp_All is Temperature; -- UndCC_Valid
+
+   -- Valid: only 'First (not the full pattern)
+   subtype Temp_Pos is Temperature range 0 .. Temperature'Last; -- UndCC_Valid
+
+   -- Valid: only 'Last (not the full pattern)
+   subtype Temp_Neg is Temperature range Temperature'First .. 0; -- UndCC_Valid
+
+   -- Violation: array index using T'First .. T'Last
+   type Temp_Array is array (Temperature'First .. Temperature'Last) of Integer; -- UndCC_Violation
+
+   -- Valid: array index using 'Range
+   type Temp_Array_Good is array (Temperature'Range) of Integer; -- UndCC_Valid
+
+   -- Valid: array index using type name
+   type Color_Array is array (Color) of Integer; -- UndCC_Valid
+
+   -- Violation: enumeration type
+   subtype Color_Full is Color range Color'First .. Color'Last; -- UndCC_Violation
+
+   -- Valid: using 'Range for enum
+   subtype Color_Good is Color range Color'Range; -- UndCC_Valid
+
+   -- Violation: attribute names in different case (Ada is case-insensitive)
+   subtype Index_Full is Index range Index'FIRST .. Index'LAST; -- UndCC_Violation
+
+   -- Valid: different type names on each side
+   type Mixed_Array is array (Color'First .. Index'Last) of Boolean; -- UndCC_Valid
+
+   -- Violation: built-in Integer type (the "huge range" caution from the guideline)
+   subtype Big_Int is Integer range Integer'First .. Integer'Last; -- UndCC_Violation
+
+   -- Valid: qualified expression uses apostrophe differently (not an attribute access)
+   Sixty : constant Temperature := Temperature'(60); -- UndCC_Valid
+
+end Test_5_5_1;

CodeCheck/Published Standards/Ada 95/ADA95_5.5.6/check.upy

@@ -0,0 +1,113 @@
+ERR1 = "Use <= or >= instead of = when comparing real operands"
+
+
+def ids():
+    return ("ADA95_5.5.6",)
+
+
+def name(id):
+    return {
+        "ADA95_5.5.6": "Published Standards/Ada 95/5.5.6 Accuracy of Operations With Real Operands",
+    }[id]
+
+
+def tags(id):
+    return {
+        "ADA95_5.5.6": [
+            "Language: Ada",
+            "Standard: Ada 95",
+            "Expressions",
+        ],
+    }.get(id, [])
+
+
+def detailed_description(id):
+    return {
+        "ADA95_5.5.6": """
+<p><b>Guideline</b></p>
+<p>&#8226; Use <code>&lt;=</code> and <code>&gt;=</code> in relational expressions with real operands instead of <code>=</code>.</p>
+
+<p><b>Example</b></p>
+<pre><code language="Ada">Current_Temperature   : Temperature :=       0.0;
+Temperature_Increment : Temperature := 1.0 / 3.0;
+Maximum_Temperature   : constant    :=     100.0;
+...
+loop
+   ...
+   Current_Temperature :=
+         Current_Temperature + Temperature_Increment;
+   ...
+   exit when Current_Temperature >= Maximum_Temperature;
+   ...
+end loop;
+</code></pre>
+
+<p><b>Rationale</b></p>
+<p>Fixed- and floating-point values, even if derived from similar expressions, may not be exactly equal. The imprecise, finite representations of real numbers in hardware always have round-off errors so that any variation in the construction path or history of two real numbers has the potential for resulting in different numbers, even when the paths or histories are mathematically equivalent.</p>
+<p>The Ada definition of model intervals also means that the use of <code>&lt;=</code> is more portable than either <code>&lt;</code> or <code>=</code>.</p>
+
+<p><b>Notes</b></p>
+<p>Floating-point arithmetic is treated in Guideline 7.2.7.</p>
+
+<p><b>Exceptions</b></p>
+<p>If your application must test for an exact value of a real number (e.g., testing the precision of the arithmetic on a certain machine), then the <code>=</code> would have to be used. But never use <code>=</code> on real operands as a condition to exit a loop.</p>
+
+<p><b>Developer's Note</b></p>
+<p>The check may produce false negatives when both operands are complex expressions (e.g., function calls or arithmetic subexpressions) rather than named variables or parameters, since the real type cannot be determined without evaluating the full expression type.</p>
+""",
+    }[id]
+
+
+def test_entity(file):
+    return file.kind().check("Ada File")
+
+
+def _is_real_type(ent):
+    if not ent:
+        return False
+
+    type_ref = ent.ref("Typed", "Type")
+    if not type_ref:
+        return False
+
+    type_ent = type_ref.ent()
+
+    while type_ent:
+        type_def = str(type_ent.type()).lower() if type_ent.type() else ""
+        if "digits" in type_def or "delta" in type_def:
+            return True
+        derive_ref = type_ent.ref("Derivefrom")
+        type_ent = derive_ref.ent() if derive_ref else None
+
+    return False
+
+
+def check(check, file):
+    lex = file.lexer().first()
+
+    while lex:
+        if lex.token() == "Operator" and lex.text() == "=":
+            left_lex = lex.previous(True, True)
+            left_ent = (
+                left_lex.ent()
+                if left_lex and left_lex.token() == "Identifier"
+                else None
+            )
+
+            right_lex = lex.next(True, True)
+            right_ent = (
+                right_lex.ent()
+                if right_lex and right_lex.token() == "Identifier"
+                else None
+            )
+
+            if _is_real_type(left_ent) or _is_real_type(right_ent):
+                check.violation(
+                    left_ent or right_ent,
+                    file,
+                    lex.line_begin(),
+                    lex.column_begin(),
+                    ERR1,
+                )
+
+        lex = lex.next(True, True)