.. _Non Standard Checks:

Non Standard Checks
===================
   
.. list-table::

   * - **ID**
     - **Message**
     - **Notes/Examples**
   * - ASSERTION_IN_CUNIT_SCOPE
     - Deferred immediate assertion not allowed in compilation-unit scope
     - ``assert #0 (0 == 0);``
   * - EXTERN_DECLARATION_IN_CUNIT_SCOPE
     - Extern function not allowed in compilation-unit scope
     - ``extern int foo();``
   * - FATAL_SYSTEM_TASK_FIRST_ARGUMENT
     - Expecting 0, 1 or 2 as first argument to '$fatal' system task
     - ``$fatal(4, "Sorry");``
   * - BEGIN_END_OUTSIDE_GENERATE
     - 'begin/end' generate block not allowed
     -  
   * - CONFIGURATION_RULE
     - Unexpected configuration rule
     -  
   * - MISSING_CONFIGURATION_RULE_SEMI
     - Expecting ';' after configuration rule
     - ``instance top.sub.u1 liblist gateLib``
   * - TIMEUNIT_IN_CLASS_SCOPE
     - # declaration not allowed in class scope
     - .. code-block::
        
          class foo;
             timeunit 100ps;
             timeprecision 10fs;
          endclass
   * - FUNCTION_PROTOTYPE
     - Expecting 'function' keyword in prototype declaration
     - ``extern void foo();``
   * - PURE_QUALIFIER_POSITION
     - 'pure' qualifier not allowed before # qualifier
     - ``protected pure local virtual function void wrong_order();``
   * - CONSTRUCTOR_LIFETIME
     - 'automatic' lifetime for class constructor not allowed
     - .. code-block::
      
          class foo;
            function automatic new();
            endfunction
          endclass
   * - CLASS_VARIABLE_LIFETIME
     - 'automatic' lifetime for class variable # not allowed
     - .. code-block::
      
          class foo;
              automatic int bar;
          endclass
   * - CONSTRAINT_DEFAULT_QUALIFIER
     - 'default' qualifier for constraint not allowed
     - .. code-block::
      
          default constraint a_cons {
              x == 0;
              y <= 0;
          }
   * - HARD_SOLVE_BEFORE
     - 'hard' qualifier not allowed
     - .. code-block::
      
          constraint c_cons {
              x == 0;
              y <= 0;
              solve x before y hard;
          }
   * - SOFT_AFTER_EXPRESSION
     - 'soft' must be placed before the expression
     - .. code-block::
      
          constraint c_cons {
              x dist {0, 1} soft; 
          }
   * - SOFT_BEFORE_SOFT
     - 'soft' not allowed before 'soft'
     - .. code-block::
      
          constraint c_cons {
              soft soft x;
          }
   * - SOFT_BEFORE_UNIQUE
     - 'soft' not allowed before 'unique'
     - .. code-block::
      
          constraint c_cons {
              soft unique {}
          }
   * - SOFT_BEFORE_IF
     - 'soft' not allowed before 'if'
     - .. code-block::
      
          constraint c_cons {
              soft if (condition) {}
          }
   * - SOFT_BEFORE_FOREACH
     - 'soft' not allowed before 'foreach'
     - .. code-block::
      
          constraint c_cons {
              soft foreach (array[i]) {}
          }
   * - SOFT_BEFORE_DISABLE
     - 'soft' not allowed before 'disable'
     - .. code-block::
      
          constraint c_cons {
              soft disable soft x;
          }
   * - PARENTHESES_DIST_EXPRESSION
     - Enclosing parentheses not allowed for dist expression
     - .. code-block::
      
          constraint c_cons {
              (x dist {0,1});
              (foreach (array[i]) { });
              (x -> 2);
          }
   * - SPACE_DIST_WEIGHT
     - Unexpected space between : and # in dist weight
     - .. code-block::
      
          rand int x; constraint c_cons {
              x dist {0 : = 3};
          }
   * - DYNAMICPARAM
     - Unexpected keyword 'dynamicparam'
     - ``dynamicparam p = 3;``
   * - CONST_AFTER_STATIC
     - 'const' qualifier not allowed after 'static'
     - ``static const int x = 0;``
   * - LIFETIME_QUALIFIER_BEFORE_VAR
     - # qualifier not allowed before 'var'
     - ``automatic var int x = 0;``
   * - TYPEDEF_COVERGROUP
     - Typedef of covergroup not allowed
     - ``typedef covergroup cg;``
   * - TYPEDEF_DATATYPE
     - Explicit data type required (implicit 'logic' is assumed)
     - ``typedef [3:0] new_type;``
   * - IMPLICIT_DATA_TYPE_IN_DECLARATION
     - Expecting net type (e.g. wire) or 'var' keyword before implicit data type
     - ``[3:0] var_or_net;``
   * - PACKED_DIMENSION_INTEGER_TYPE
     - Unexpected packed dimension for integer type
     - .. code-block::
      
          function integer[3:0] foo();
          endfunction
   * - PACKED_STRUCT_WITH_SIGNING
     - Expecting 'packed' before signing
     - .. code-block::
      
          typedef struct signed {
              int x;
              int y;} 
          packed_with_sign;
   * - TYPEOF_SYSTEM_FUNCTION
     - '$typeof' system function not allowed
     - .. code-block::
      
          bit[3:0] field;
          typedef $typeof(field) new_type;
   * - PACKAGE_SCOPE_IN_ENUM_BASE_TYPE
     - Package scope before enum base type not allowed
     - .. code-block::
      
          package package_name;
            typedef int id;
          endpackage
          
          typedef enum package_name::id {R,G,B} new_enum;
   * - ENUM_IMPLICIT_DATATYPE
     - Explicit data type required (implicit # is assumed)
     - ``typedef enum [1:0] {R,G,B} new_enum;``
   * - DELAY_VALUE_EXPRESSION
     - Expecting parentheses around bit-select and part-select
     - ``always ... #del[0] ok = 1;``
   * - PARAMETER_DYNAMIC_ARRAY
     - Fixed size required for parameter dimension
     - .. code-block::
      
          parameter logic flag1[] = '{2};
          localparam logic flag2[] = '{2};
   * - CONST_EXPR_PACKED_DIMENSION
     - Expecting constant range instead of constant expression for packed dimension
     - ``enum bit[1] { A, B } foo;``
   * - QUALIFIER_BEFORE_METHOD
     - # qualifier not allowed before method keyword
     - .. code-block::
      
          static function foo(); 
            
            ... 
          
          endfunction
   * - CLASS_SCOPE_END_LABEL
     - Class scope #:: before end label not allowed
     - ``... endfunction : class_scope::func_name``
   * - HIERARCHICAL_INTERFACE_IDENTIFIER
     - Hierarchical interface identifier #.# not allowed
     - ``task id1.id2.id3();``
   * - PROTOTYPE_RETURN_DATA_TYPE
     - Expecting return data type or void for function prototype
     - ``extern function doCheck();``
   * - DPI_DECLARATION_STRING
     - Expecting "DPI" or "DPI-C"
     - ``import "DPI_C" init_1 = function void moo();``
   * - EMPTY_ARGUMENTS_LIST
     - Empty arguments list '()' not allowed when arguments are declared inside function / task body
     - .. code-block::
      
          function void foo();
              output integer x;
          endfunction
   * - DYNAMIC_ARRAY_INITIALIZATION
     - Unexpected 'new' initialization for dynamic array
     - .. code-block::
      
          task foo(input int a[] = new[1]);
          endtask
   * - CLASS_INSTANCE_INITIALIZATION
     - Unexpected 'new' initialization for class instance
     - .. code-block::
      
          function void foo(cls i = new());
          endfunction
   * - MODPORT_PORTS_DECLARATION
     - Unexpected empty modport ports declaration
     - ``modport mp_name();``
   * - MODPORT_PORT_DIRECTION
     - Explicit direction required for port #
     - ``modport mp_name(x, input y);``
   * - MODPORT_HIERARCHICAL_PORT
     - Hierarchical identifier not allowed in modport port declaration
     - ``modport master (output sb.gnt);``
   * - MODPORT_IMPORT_EXPORT
     - Unexpected .* used in modport import / export declaration
     - ``modport master (import sb.\*);``
   * - REPETITION_IN_SEQUENCE
     - Goto repeat '[->' and non-consecutive repeat '[=' operators not allowed
     -  
   * - COVERPOINT_IFF_EXPRESSION
     - Expecting parentheses around coverpoint 'iff' expression
     - ``coverpoint a iff test;``
   * - BINS_IFF_EXPRESSION
     - Expecting parentheses around bins 'iff' expression
     - ``bins a = { [0:63],65 } iff ana;``
   * - COVERCROSS_IFF_EXPRESSION
     - Expecting parentheses around covercross 'iff' expression
     -  
   * - BINS_SELECTION_IFF_EXPRESSION
     - Expecting parentheses around bins selection 'iff' expression
     -  
   * - WILDCARD_BINS_SELECTION
     - 'wildcard' not allowed for bins selection
     - .. code-block::
      
          covergroup cov @(posedge clk);
            aXb : cross a, b { wildcard bins i_zero = binsof(a) intersect { 0 }; }
          endgroup
   * - HIERARCHICAL_ACCESS_IN_BINS_EXPRESSION
     - Cover point hierarchical identifier not allowed in bins expression
     - ``binsof(x.cover_point_id.bin_id);``
   * - SELECT_IN_BINS_EXPRESSION
     - Select not allowed in bins expression
     - ``binsof(cover_point_id.bin_id[3]);``
   * - COVERPOINT_EXPRESSION_TYPE
     - Coverpoint expression should be of an integral data type
     -  
   * - COVERGROUP_EXPRESSION
     - Expecting constant expression or non-ref covergroup argument, found #
     - .. code-block::
      
          int field;
          covergroup cg() with function sample(int unsigned foo);
            coverpoint foo {
                ignore_bins ignore = foo with (field > 2);    
            }
          endgroup
   * - CONCATENATION_MULTIPLIER
     - Expecting constant expression as concatenation multiplier, found #
     - .. code-block::
      
          int field = 8;
          logic[7:0&#93 x = { field {1'b1}}
   * - PULL_GATE_INSTANCE
     - Multiple terminals to a pull gate instance not allowed
     - ``pullup p (t1, t2, t3);``
   * - IMPLICIT_INSTANCE_NAME
     - Implicit name not allowed for instance of #
     - .. code-block::
      
          module top(input i, output o);
            m1(.i(i), .o(o));
            endmodule
   * - PARENTHESES_GATE_TERMINAL
     - Enclosing parentheses around gate terminal not allowed
     - ``tranif0 ti0 (x, (y), z);``
   * - PARAMETER_OVERRIDE
     - Expecting parentheses around parameter override
     - .. code-block::
      
          module m #(P1=1)();
          endmodule
          
          module top();  
            m # 3 u_m();
          endmodule
   * - EMPTY_ORDERED_PARAMETER_OVERRIDE
     - Empty parameter override in ordered list not allowed
     - ``xmm_atomic_gen #(transaction, ,"Atomic Gen") msg_rx_gen;``
   * - DOT_STAR_CONNECTION
     - Unexpected whitespace character(s) between '.' and '*'
     - ``m u_m(. *, .port(0));``
   * - MULTIPLE_DOT_STAR_CONNECTIONS
     - Dot start port connection '.*' cannot appear more than once in the port list
     - ``m u_m(.*, .*);``
   * - INITIAL_BLOCK_SCOPE
     - Unexpected initial block construct
     - .. code-block::
      
          package p1;
              initial begin end;
          endpackage
   * - FINAL_BLOCK_SCOPE
     - Unexpected final block construct
     - .. code-block::
      
          package p1;
              final begin end;
          endpackage
   * - SELECT_IN_EVENT_CONTROL
     - Select in event control not allowed
     - ``@u_m3_1.a[1];``
   * - EVENT_TRIGGER
     - 'class_name::' not allowed in event trigger construct
     - ``'->' a_class::a;``
   * - DISABLE_STATEMENT
     - 'class_name::' not allowed in disable statement
     - ``disable a_class::a;``
   * - EMPTY_CASE_STATEMENT
     - Empty case statement not allowed
     - .. code-block::
      
          case (x)
          
          endcase
   * - EMPTY_ASSIGNMENT_PATTERN
     - Empty assignment pattern '{} not allowed
     - ``x = '{};``
   * - MISSING_FOR_LOOP_INITIALIZATION
     - 'for' loop variable initialization required
     - .. note::
      
           Not applicable in IEEE 1800-2012 standard syntax or newer.
           
       ``for ( ; i < 10; i++) ...``
   * - MISSING_FOR_LOOP_CONDITION
     - 'for' loop conditional expression required
     - .. note::
      
           Not applicable in IEEE 1800-2012 standard syntax or newer.
           
       ``for (i = 0; ; i++) ...``
   * - MISSING_FOR_LOOP_STEP
     - 'for' loop step required
     - .. note::
      
           Not applicable in IEEE 1800-2012 standard syntax or newer.
           
       ``for (i = 0; i < 10; ) ...``
   * - FOREACH_LOOP_CONDITION
     - Multidimensional array select not allowed in foreach loop condition
     - .. note::
      
           Strict only check. See +dvt_strict_non_standard_checks build directive on how to activate it.
           
       ``foreach (array[val][i]) ...``
   * - FOR_LOOP_INITIALIZATION
     - Expecting assignment in 'for' loop variable initialization
     - ``for (++i;i<10; i++) begin end``
   * - SELECT_IN_WEIGHT
     - Select in weight specification not allowed
     - ``randsequence() ... first : add := array[0]; endsequence``
   * - PARALLEL_PATH_DESCRIPTION
     - List of inputs in parallel path description not allowed
     - ``(in1,in2 => q[1]) = 1;``
   * - RANGE_IN_MULTIPLE_CONCATENATION
     - Range in multiple concatenation not allowed
     - ``x = {0:3{1}};``
   * - ASSIGNMENT_PATTERN
     - Expecting assignment pattern '{...} instead of concatenation
     - ``x = {a : '0, b : '1};``
   * - ASSIGNMENT_PATTERN_CONTEXT
     - Assignment pattern not allowed outside assignment-like context (could not determine data type)
     - ``if (struct_signal == '{ a, b }) ...``
   * - SCALAR_ASSIGNMENT_PATTERN
     - Variable of 1-bit scalar type # not allowed as target of assignment pattern
     - ``bit x = '{ '0 };``
   * - TARGET_UNPACKED_ARRAY_CONCATENATION
     - Unpacked array concatenation not allowed as target expression
     - ``.out({ a, b })``
   * - STREAM_CONCATENATION_TYPE
     - Packed dimension on stream concatenation type not allowed
     - ``result = { >> bit [7:0] { variable_name } };``
   * - RANDOMIZE_ARGUMENT
     - Range selection of randomize argument # not allowed
     - ``std::randomize(rand_var[7:0]) with {...};``
   * - INSIDE_OPERATOR
     - 'inside' operator in constant expression not allowed
     - ``int y[a inside {b, c} ? 10 : 2];``
   * - INSIDE_OPERATOR_RANGE
     - Expecting curly braces {} around 'inside' operator range
     - ``if ( a inside x ) ...``
   * - TYPE_CASTING
     - Expecting tick before type casting expression
     - ``int(some_var)``
   * - NULL_CONSTANT_EXPRESSION
     - Expecting constant expression instead of 'null'
     - ``class my_class #(parameter string x = null``
   * - TIME_VALUE
     - Unexpected white space between number and time value
     - ``timeunit 10 ps;``
   * - HIERARCHICAL_CLASS_ACCESS
     - Class scope resolution access '::' not allowed
     - ``a.b.c::enum_value``
   * - SELECT_IN_CROSS_ITEMS_LIST
     - Select in cross items list not allowed
     - .. code-block::
      
          covergroup g2 @(posedge clk);
              AxC: cross color[2], pixel_adr;
          endgroup
   * - HIERARCHICAL_ROOT_ACCESS
     - Unexpected '$root' name before package or class scope access
     - ``$root.my_pkg::my_signal``
   * - COMMA_AFTER_ATTRIBUTE_INSTANCE
     - Attribute instance followed by ';' not allowed
     - ``(\* full_case, parallel_case; \*)``
   * - CONST_ATTRIBUTE_INSTANCE
     - 'const' for attribute instance not allowed
     - ``(\* const int full_case=1, parallel_case \*)``
   * - ATTRIBUTE_INSTANCE_DATA_TYPE
     - Attribute instance data type not allowed
     - ``(\* integer library_binding = 1, something = 1 \*)``
   * - SELECT_IN_ATTRIBUTE_INSTANCE
     - Select in attribute instance not allowed
     - ``(\* cds_net_set[0:2] = {"a", "b", "c"} \*)``
   * - TYPEOF_SYSTEM_TASK
     - Unexpected '$typeof' system task
     - ``$typeof(a) b;``
   * - KEYWORD_AS_IDENTIFIER
     - Reserved keyword # not allowed as identifier
     - instance, restrict, checker, table, cell, config, design
   * - MULTIPLE_BINS
     - Specification of multiple bins dimension not allowed
     - ``wildcard bins trans 2 = ({1'bx} => {1'bx});``
   * - ASSERTION_STATEMENT_ATTRIBUTE_INSTANCE
     - Expecting attribute instance after block identifier # for procedural assertion statement
     - ``(\* cover_attribute \*) block_identifier : cover property ...``
   * - SYSTEM_FUNCTION_ARGUMENTS
     - Maximum number of arguments for # system function is #
     - ``$typename(x, 39);``
   * - PARENTHESES_PATTERN
     - Enclosing parentheses around pattern not allowed
     - matches (tagged VAL .c)
   * - WILDCARD_EQUALITY_OPERATOR
     - Expecting wildcard operator '==?' instead of '=?='
     -  
   * - WILDCARD_INEQUALITY_OPERATOR
     - Expecting wildcard operator '!=?' instead of '!?='
     -  
   * - STRING_CONTINUATION
     - Expecting '\\' to continue the string on the next line
     - .. code-block::
      
          string str = "string is splittedon 
          
          multiple lines";
   * - STRING_CONTINUATION_WS
     - White-space not allowed after '\\' line continuation
     - .. code-block::
      
          string str = "string is splitted \\[white-space]
     
          \\[white-space]
          
          on multiple lines";
   * - COMPILER_GUARD
     - Expecting identifier after \`ifdef, \`ifndef, \`elsif instead of \`#
     -  
   * - USELIB_DIRECTIVE
     - Unexpected Verilog-XL directive \`uselib, use -y, -v, and +libext command line flags instead
     -  
   * - LIBRARY_PATH
     - Quotes for library path specification not allowed
     - ``library rtlLib "top.v";``
   * - MACRO
     - "Unexpected macro: \`#
     - 
   * - MACRO_TEXT
     - Macro text string must terminate with \`" instead of "
     - ``$sformat(errStr, \`"ID``_``SUFFIX SIGNAL is %b",SIGNAL);``
   * - MACRO_MULTILINE_DELIMITER
     - Unexpected whitespace character(s) after macro multiline delimiter
     - .. code-block::
      
          \`define my_macro int i; \\ 
          
          int j;
   * - EXPONENT_FORMAT_TIME_VALUE
     - Unexpected exponent format for time value
     - ``#(1.0e9ns)``
   * - API
     - Unexpected method / field #
     - .. note::
      
           Strict only check for some API. See +dvt_strict_non_standard_checks build directive on how to activate all.
   * - NOF_PARAMETER_OVERRIDES
     - Expected # parameter overrides, found #
     - .. code-block::
      
          module mod;
          endmodule 
          
          ... 
          
          mod#(2) field;
   * - MISSING_FUNCTION_IMPLEMENTATION
     - # extern function is not implemented
     -  
   * - MISSING_TASK_IMPLEMENTATION
     - # extern task is not implemented
     -  
   * - FUNCTION_IMPLEMENTATION_SCOPE
     - Function implementation of # must be in the same scope as class #
     -  
   * - TASK_IMPLEMENTATION_SCOPE
     - Task implementation of # must be in the same scope as class #
     -  
   * - CONSTRAINT_IMPLEMENTATION_SCOPE
     - Constraint implementation # must be in the same scope as class #
     -  
   * - MODPORT_IMPORT_EXPORT_PORT
     - Expecting method name instead of interface signal name #
     - .. code-block::
      
          class foo;
          endclass
          
          interface bar(input clk);  
            foo field;  
            modport mp1(export field);
          endinterface
   * - SELECT_METHOD_CALL
     - Select not allowed after # method call
     - ``m4.foo()[0]``
   * - EVENT_CONTROL_EXPRESSION
     - Expecting singular data type for event control expression instead of type #
     - .. code-block::
      
          initial begin
              @(cif_enable) $display("list_of_arguments");
          end
   * - METHOD_OVERRIDE_ARGUMENT_NAME
     - Argument name # of method # does not match # of override #
     - .. code-block::
      
          class foo1;
              virtual function bar(int base_name);
              endfunction
          endclass
          
          class foo2 extends foo1;
              virtual function bar(int child_name);
              endfunction
          endclass
   * - FUNCTION_IMPLEMENTATION_RETURN_TYPE
     - Return type # of function # must be the same as prototype return type (non-standard use of type alias)
     - .. code-block::
      
          typedef bit my_type;
          
          class foo;
              extern function bit boo();
          endclass
          
          function my_type foo::boo();
          endfunction
   * - FUNCTION_IMPLEMENTATION_INTERNAL_RETURN_TYPE
     - Internal return type # for the implementation of extern method # requires scope resolution
     - ``function cls_internal_type cls::foo(); ...``
   * - METHOD_IMPLEMENTATION_ARGUMENT_TYPE
     - Argument type # of method # must be the same as prototype argument type (non-standard use of type alias)
     - .. code-block::
      
          typedef bit my_type;
          class foo;
              extern function bit boo(bit arg);
              extern function bit goo(bit arg);
          endclass
          
          function bit foo::boo(my_type arg);
          endfunction
   * - VOID_CAST_OF_VOID_FUNCTION
     - Void cast of void function # not allowed
     - ``void'(void_return_function())``
   * - LOGICAL_NEGATION
     - Operand of type # not allowed with logical negation # (use == null instead)
     - ``if (!class_obj) ...``
   * - BINARY_LOGICAL_OPERATOR
     - Operand of type # not allowed with binary logical operator # (use != null instead)
     - ``if (class_obj && class_obj.field == 0) ...``
   * - DYNAMIC_ARRAY_NULL_OPERATION
     - # operator is undefined for dynamic array # and 'null'
     - ``if (array == null) ...``
   * - NUMERIC_NULL_OPERATION
     - # operator is undefined for numeric type # and 'null'
     - ``if (sig == null) ...``
   * - NUMERIC_NULL_OPERATION_IN_ASSOCIATION
     - Illegal ''null'' # for numeric type #
     - ``'{ null : 0 }``     
   * - STRING_OPERATION
     - Explicit 'string' cast required for # operand of type #
     - .. code-block::
      
          string a; 
          int b; 
          if (a == b) ...
   * - ENUM_ASSIGNMENT
     - Explicit cast required when assigning # to variable # of enum type #
     - .. code-block::
      
          enum_type a; 
          a+=1;
   * - ENUM_ASSIGNMENT_IN_ASSOCIATION
     - Explicit cast required when assigning # to enum type #
     - .. code-block::
      
          enum_type array[enum_type];
          array = '{ 1 : 1 };
   * - ENUM_COMPARISON
     - Explicit cast required when comparing # to variable # of enum type #
     - .. code-block::
      
          enum_type a; 
          if (a < 1) ...
   * - ENUM_RETURN
     - Explicit cast to enum type # required when returning #
     - .. code-block::
      
          function enum_type foo();
             return 1; 
          endfunction
   * - DIFFERENT_ENUMS_ASSIGNMENT
     - Explicit cast required when assigning to enum type # from enum type #
     - .. code-block::
      
           enum_type a;
           a = other_enum_literal;
   * - DIFFERENT_ENUMS_COMPARISON
     - Explicit cast required when comparing enum type # to enum type #
     - .. code-block::
      
          enum_type a; 
          if (a < other_enum_literal) ...
   * - EVENT_CONTROL
     - The following events must be of a singular data type:#
     - .. code-block::
      
          always @(a or b) begin
              c = a[0] & b;
          end
   * - IMPORT_TYPE_WITHOUT_EXPORT
     - Package # must export type #
     - ``import pkg::not_exported_type;``
   * - TYPE_SPECIALIZATION
     - Type # is already a specialization of #
     - .. code-block::
      
          typedef cls#(.T(int)) type_alias;
          type_alias#(.T(int)) field;
   * - REPEAT_CONDITION_UNPACKED_ARRAY
     - Unpacked array # not allowed as repeat condition
     - .. code-block::
      
          int array[2]; 
          repeat (array) ...
   * - REPEAT_CONDITION_STRING
     - String variable # not allowed as repeat condition
     - .. code-block::
      
          string str; 
          repeat (str) ...
   * - REPEAT_CONDITION_UNPACKED_STRUCT
     - Unpacked struct / union # not allowed as repeat condition
     - .. code-block::
      
          struct { int x; } val; 
          repeat (val) ...
   * - INTERFACE_NAME_SELF_REFERENCE
     - Interface type name # not allowed as self reference
     - ``virtual interface_name var = interface_name;``
   * - INVALID_VIRTUAL_INTERFACE
     - Interface # containing interface ports cannot be used as a virtual interface
     - ``interface intf(interface port)``
   * - INVALID_RAND_MODE_CALL
     - 'rand_mode' call not allowed for non-random variable #
     - .. code-block::
      
          int x;
          
          function foo();
              x.rand_mode(0);
          endfunction
   * - PORT_DEFAULT_VALUE
     - Ouput / Inout / Ref port # cannot have a default value
     - 
   * - ANSI_ARGUMENT_REDECLARATION
     - Redeclaration of ANSI argument # is not allowed
     - .. code-block::
      
          function foo(input ansi_arg);
              logic ansi_arg;
          endfunction
   * - ANSI_PORT_REDECLARATION
     - Redeclaration of ANSI port # is not allowed
     - .. code-block::
      
          module foo(input ansi_port);
              logic ansi_port;
          endmodule
   * - REDUNDANT_NON_ANSI_PORT_DIRECTION
     - Declaration of port # has redundant input / output / inout direction
     - .. code-block::
      
          module foo(arg);
              input arg;    
              input wire arg;
          endmodule
