Type check on type aliases

[gidesa]

Hello,
I have this situation, with a type alias of integer:

Code: Pascal  [Select][+][-]

1. type
2.   MyInteger = type integer;  // note the "type" before "integer"
3. var
4.   mi: MyInteger;
5.   i: integer;
6. begin
7.   mi:=i;
8. end;
9.  

As says the manual, MyInteger internally results as a different type from integer.
But the compiler accept the assignment without any error or warning.
Is possible instead to generate an error?
With that definition the programmer wants explicitly a new type, not a simple alias of integer.
All checks during compilation time are a great aid, in my opinion. And in this case FPC compiler could be
almost ready to add this check.
Thanks

[cdbc]

Hi
I think it's because they're value compatible, it is also possible to assign a word to a byte, just beware of the possible funny/wrong result 
Regards Benny

[alpine]

Wrap it in a record:

Code: Pascal  [Select][+][-]

1. type
2.   MyInteger = record
3.     I: Integer;
4.   end;
5.  
6.   // Overload operators as needed
7.   operator +(A,B: MyInteger) C: MyInteger;
8.   begin
9.     C.I := A.I + B.I;
10.   end;  

[Thaddy]

The specialized types are assignment compatible, but you can check if the types are equal.

[gidesa]

Yes, I could use records, and I have tried in other cases.
And sure, at run time I can check types and more.
But it not resolve the issue of having checks at compile time, in my opinion is much better.
For example, a numeric type record with run time controls (Delphi syntax):

Code: Pascal  [Select][+][-]

1. // integer bounded to 1-10 range
2. type
3.   integer1b10 = record
4.   strict private
5.     num: Integer;
6.   public
7.     class operator Implicit(const N: integer): integer1b10;
8.     { Other operator as:
9.     class operator Implicit(const N: integer1b10): integer;
10.     class operator LessThan(N: integer1b10; I: integer): Boolean;
11.     class operator Add(N: integer1b10; I: integer): integer1b10;
12.     class operator Inc(N: integer1b10) : integer1b10;
13.     ................
14.     }
15.   end;
16.  
17. class operator integer1b10.Implicit(const N: integer): integer1b10;
18. begin
19.   if (1<=N) and (N<=10) then
20.     Result.num:=N
21.   else
22.     raise EOverflow.Create('integer1b10: out of 1-10 bounds');
23. end;    
24.  
25. var
26.   i10: integer1b10;
27.  
28. begin
29.   i10:=20;  // no warning/error at compile time; generate exception at run time
30. end;
31.  

[alpine]

You asked for an assignment-incompatible type. You can't assign integer to it (compile time) unless you overload the assignment operator.

[gidesa]

In the integer1b10 example, the assignment operator (from integer) is overloaded.
It's the class operator Implicit.
But no check at compile time. 

[Thaddy]

Yes, I could use records, and I have tried in other cases.

Why? That is silly. type 1 is not equal to type 1 type 1 anyway.

[alpine]

In the integer1b10 example, the assignment operator (from integer) is overloaded.
It's the class operator Implicit.
But no check at compile time. 

Then do not overload Implicit(). Can you paraphrase the original question, please?

[Joanna]

I’m not sure what the purpose of trying to create a new type of integer would be. Of course a type of integer would be an integer.  This reminds me of ctk...

[gidesa]

Briefly, from FPC reference guide:

"
3.8  Type aliases
-------------------

............

Type
MyInteger = Type Integer;
This not only creates a new name to refer to the Integer type, but actually creates a new type. That
is, two variables:
Var
A : MyInteger;
B : Integer;
Will not have the same type from the point of view of the compiler. However, these two types will
be assignment compatible. That means that an assignment
A:=B;
will work.
The difference can be seen when examining type information:
    If TypeInfo(MyInteger)<>TypeInfo(Integer) then
                        Writeln('MyInteger and Integer are different types');
"

My question: would be possible, modifying the compiler, to have a warning or error AT COMPILE TIME, instead that the silent assigment compatibility? Maybe with a compiler option/switch.
As Joanna and Thaddy observe,  why to simply assign an alias to an integer (and, indeed, to every other type, native or user) ? The manual well explains situations where this is useful.
Maybe FPC developers do not plan to add this compile check. Whatever is the answer, FPC remains a great compiler for me.
Thanks

[Joanna]

I don’t think they will change it, this has been thoroughly discussed on a previous occasion