Name Resolution Bugs (NRS) Class

Definition

We define Name Resolution Bugs (NRS) as follows:

The name of an object, a function, or a data type is resolved improperly or bound to an improper data type or implementation.

Taxonomy

Fig. 1 depicts NRS causes, attributes and consequences.

Operations

The NRS operations are: Refer and Call. They reflect the improper name resolution, and data type, data, or implementation binding.

Operation Value	Definition
Refer	Use a name in local or remote scopes of source code. The Type System resolves the name and binds a data type to it.
Call	Invoke a function implementation. The Type System binds the implementation to the resolved function name. A polymorphic implementation is first resolved and then bound.

Causes

The graph of causes shows that there are three main causes for name resoultion bugs: Improper Operation, Improper Scope, Improper DataType, and Improper Function.

Improper Operation
Value	Definition	Examples
Erroneous	The Type System or a compute function implementation has a bug.	Incorrect data type inference. Wrong order or number of arguments to a function call. Incorrect deep objects comparison implementation.

Operands
Concept	Definition
Data Value	A numeric, text, pointer/address, or boolean value stored in an object’s memory.
Data Type	A set of allowed values and the operations allowed over them.
Function	An organized block of code that when called takes in data, processes it, and produces a result(s).

Consequences

The graph of consequences shows Improper Data Value, Improper Data Type, and Improper Function.

Improper Data Value
Concept	Definition
Under Range	Data value is smaller than type’s lower range.
Over Range	Data value is larger than type’s upper range.
Flipped Sign	Sign bit is overwritten from type related calculation.
Wrong Argument Value	Inaccurate input data value; i.e., non-verified for harmed semantics.
Wrong Object Resolved Value	Object is resolved from wrong scope.
Reference vs. Object	Object’s address instead of object’s data value.
Wrong Result	Incorrect value from type conversion or computation.
Wrap Around	A moved around-the-clock value over its data type upper or lower range, as it exceeds that range. (Integer Over-/Under-flow is a wrapped-around the upper/lower range integer value; may become very small/large and change to the opposite sign.)
Truncated Value	Rightmost bits of value that won’t fit type size are cut off.
Distorted Value	Incorrect value (although fits type size) due to sign flip or signed/unsigned and vice versa conversions.
Rounded Value	Real number value precision loss.

Improper Data Type
Concept	Definition
Wrong Type	Data type range or structure is not correct.
Wrong Type Resolved	Data type is resolved from wrong scope.
Wrong Object Resolved Type	Object is resolved from wrong scope,so it’s data type might be wrong.
Wrong Sign Type	Unsigned instead of signed data type is specified or vise versa.
Wrong Precision Type	Higher precision data type is needed (e.g. double instead of float).
Incomplete Type	Specific constructor, method, or overloaded function is missing.
Mismatched Argument Type	Argument’s data type is different from function’s parameter data type.
Wrong Generic Type	Generic object instantiated via wrong type argument.
Confused Subtype	Object invoking an overriden function is of wrong subtype data type.
Wrong Argument Type	Argument to an overloaded function is of wrong data type.

Improper Function
Concept	Definition
Missing Overridden Function	Function implementation in a particular subclass is absent.
Missing Overloaded Function	Implementation for particular function parameters’ data types is absent.
Wrong Function Resolved	Function is resolved from wrong scope.
Wrong Generic Function Bound	Implementation for a wrong data type is bound due to wrong generic type arguments.
Wrong Overridden Function Bound	Implementation from wrong subtype is bound due to a wrong invoking subtype object.
Wrong Overloaded Function Bound	Wrong overloaded implementation is bound due to wrong function arguments.

Attributes

The attributes of NRS are:

Name	Value	Definition
Source Code	Codebase	The operation is in programmer’s code – in the application itself.
	Third Party	The operation is in a third party library.
	Standard Library	The operation is in the standard library for a particular programming language.
	Compiler/Interpreter	The operation is in the language processor that allows execution or creates executables (compiler, assembler, interpreter).
Data Type Kind	Primitive	Mimics the hardware units and is not built from other data types – e.g. int (long, short, signed), float, double, string, boolean.
	Structured	Builds of other data types; have members of primitive and/or structured data types – e.g. array, record, struct, union, class, interface.
Mechanism	Resolve	Look up entity name and if needed determine data type (infer from value, through hierarchy, via generic type attribute).
	Bind	Connect object data type, function return type, parameter data type, or simple function imple- mentation.
	Early Bind	Resolve subtype and set generic function imple- mentation.
	Late Bind	Resolve overriden function via subtype object and set implementation.
	Ad-hoc Bind	Resolve overloaded function via signature and set implementation.
Entity	Object	A memory region used to store data.
	Function	An organized block of code that when called takes in data, processes it, and returns a result.
	Data Type	A set or a range of values and the operations allowed over them.
	Namespace	An organization of entities’ names, utilized to avoid names collision.

Sites

NRS sites are the entities references and the function calls.

Application

Application examples are provided here.