Type compatibility in Oberon

Karl Landström 2017-10-11 (edited 2018-01-28)

The type compatibility rules in the Oberon report (2016) are not completely specified. To fill in the missing pieces, appendix A from The Programming Language Oberon-2 (1993) by Hanspeter Mössenböck and Niklaus Wirth is used here as a template, with adjustments for the 2016 edition of Oberon.

Note that Oberon uses non-strict name equivalence. This means that for a type identifier T_a, the type declarations T_b = T_a and T_c = T_a make T_b and T_c equivalent.

Same types

Two variables a and b with types T_a and T_b are of the same type if

1. T_a and T_b are both denoted by the same type identifier, or
2. T_a is declared to equal T_b in a type declaration of the form T_a = T_b, or
3. a and b appear in the same identifier list in a variable, record field, or formal parameter declaration and are not open arrays.

Equal types

Two types T_a and T_b are equal if

1. T_a and T_b are the same type, or
2. T_a and T_b are open array types with equal element types, or
3. T_a and T_b are procedure types whose formal parameter lists match.

Assignment compatible

An expression e of type T_e is assignment compatible with a variable v of type T_v if one of the following conditions hold:

1. T_e and T_v are the same type;
2. T_v is CHAR and e is a single-character string constant;
3. T_e is INTEGER and T_v is BYTE or vice versa;
4. T_v is ARRAY n OF CHAR, e is a string constant with m characters, and m < n;
5. T_e is an open array, T_v is a non-open array and their element types are equal;
6. T_e and T_v are record types and T_e is an extension of T_v and the dynamic type of v is T_v;
7. T_e and T_v are pointer types and T_e is an extension of T_v;
8. T_v is a pointer or a procedure type and e is NIL;
9. T_v is a procedure type and e is the name of a procedure whose formal parameters match those of T_v.

Array compatible

An actual parameter a of type T_a is array compatible with a formal parameter f of type T_f if

1. T_f and T_a are the same type, or
2. T_f is an open array, T_a is any array, and their element types are array compatible, or
3. T_f is ARRAY OF CHAR and a is a string.

Expression compatible

For a given operator, the types of its operands are expression compatible if they conform to the following table (which shows also the result type of the expression). Character arrays that are to be compared must contain 0X as a terminator. Type T₁ must be an extension of type T₀:

Operator	First operand	Second operand	Result type
+ − *	INTEGER, BYTE	INTEGER, BYTE	INTEGER
+ − * /	REAL	REAL	REAL
	SET	SET	SET
DIV MOD	INTEGER, BYTE	INTEGER, BYTE	INTEGER
OR & ~	BOOLEAN	BOOLEAN	BOOLEAN
= # < <= > >=	CHAR, one-char string	CHAR, one-char string	BOOLEAN
	INTEGER, BYTE	INTEGER, BYTE	BOOLEAN
	REAL	REAL	BOOLEAN
	character array, string	character array, string	BOOLEAN
= #	BOOLEAN	BOOLEAN	BOOLEAN
	SET	SET	BOOLEAN
	pointer type T0 or T1, or NIL	pointer type T0 or T1, or NIL	BOOLEAN
	procedure type T or NIL	procedure type T or NIL	BOOLEAN
IN	INTEGER, BYTE	SET	BOOLEAN
IS	type T0	type T1	BOOLEAN

Matching formal parameter lists

Two formal parameter lists match if

1. they have the same number of parameters, and
2. they have either the same function result type or none, and
3. parameters at corresponding positions have equal types, and
4. parameters at corresponding positions are both either value or variable parameters.