| Online Eiffel Documentation

EiffelStudio

# Major changes between ISE Eiffel 5.4 and ISE Eiffel 5.5

## What's new

- Full support for new convert keyword.
- Made Void, previously a feature of ANY, a keyword. This prevents the renaming of Void into not_void previously possible when it was a routine of ANY.
- Addition of the reference keyword used in generic constraints (See next point).
- Added support for reference and expanded constraints on a formal generic parameter. In other word, one can now write:

      class A [reference G]  ... end
      class B [expanded G] ... end

  to say that the valid actual generic parameters for A are always reference types, and for B are always expanded types.
- Added support for Microsoft .NET 2.0 runtime.
- Allowed agent creation on infix or prefix routines.

## Improvements

- Reduced, in classic mode, size of finalized executables by 10 to 50%.
- Improved speed of evaluation of global onces, in a multithreaded system, by having a lock-free mechanism after a once has been evaluated.
- Reduced memory usage of special of expanded which do not have any reference attributes. Before there was a 8 bytes (or 16 bytes depending on the platform) overhead per item in the special.

## Changes

- Compiler is now checking that you cannot redeclare a formal generic parameter into a reference type unless the formal generic parameter is being constraint to be always a reference type (See the What's new section above).
- Removed obsolete eifcid, eif_expand and eifexpfrom the CECIL interface, one has to use eif_type_idinstead.
- In .NET, changed the naming conventions of resources included in an assembly. The extension `.resources' is appended for resources that are originally provided as `.resx' or `.txt' files. Other files are embedded as is in the assembly and the name of the resource is the name of the file.
- In .NET, now all classes inherit from ANY. Before all classes inherited from SYSTEM_OBJECT. The consequences are:
  - You can write an Eiffel generic classes where the actual generic parameter is a .NET class.
  - If you used to inherit from .NET classes and Eiffel classes you can replace the inheritance clause below:

        class A
        inherit
        	APPLICATION_EXCEPTION
        		undefine
        			finalize,
        			equals,
        			to_string,
        			get_hash_code
        		end

        	ANY

    by the much simpler inheritance clause:

        class A
        inherit
        	APPLICATION_EXCEPTION

  - If you were using a feature of SYSTEM_OBJECT directly on Eiffel classes, now you need to assign the value to a variable entity of type SYSTEM_OBJECT. In other word:

        e: EIFFEL_CLASS
        o: SYSTEM_OBJECT
        ...
        o := e
        o.feature_of_system_object

  - The following assignment attempt will succeed whereas it failed before because SYSTEM_OBJECT did not inherit from ANY:

        a: ANY
        o: SYSTEM_OBJECT
        ...
        check o /= Void and a = Void end
        a ?= o
        check o /= Void and a /= Void end

- New format of the independent storable files which takes into account internal changes made for a better generic conformance in classic mode.
- New validity rule for expanded types: It is valid to use an expanded type of base class C in the text of a class B if and only if it satisfies the following conditions:
  - C is not a deferred class
  - C's version of the procedure default_create (inherited from ANY) is one of the creation procedures of C available to B for creation.
- New validity rule for expanded class: An expanded class C needs to have the version of the procedure default_create (inherited from ANY) as one of its creation procedure.

## Bug fixes

### Language issues

- Fixed issue about conformance checking of type containing a formal generic parameter. We would always evaluate the formal to its constraint, thus allowing the code below to be accepted where it should not have been:

      class A [G]
      feature
      	bug is
      		local
      			l_any: LIST [ANY]
      			l_g: LIST [G]
      		do
      			l_any := l_g
      			l_g := l_any
      		end

  The workaround is to use the reference keyword to guarantee that the formal generic parameter will always be instantiated with a reference type. For example the code below is correct:

      class A [reference G]
      feature
      	bug is
      		local
      			l_any: LIST [ANY]
      			l_g: LIST [G]
      		do
      			l_any := l_g
      			l_g ?= l_any
      		end

### Compiler issues

- Enabled creation of SPECIAL instances, no need to create an instance of TO_SPECIALor ARRAY to get a SPECIALinstance. Now you can simply do:

      my_special: SPECIAL [INTEGER]
      create my_special.make (10)

- Fixed incrementality issues with strip and static calls on external routines which could fail after a class has been added to or removed from the system.

### Runtime/code generation issues

- Fixed incorrect code generation which would result in a C compiler error in classic mode when assigning a Void entity to a formal generic parameter that will be instantiated as a basic type.
- In multithreaded mode, fixed dead lock on Unix platforms when evaluating global onces.
- In multithreaded mode, prevented dead lock when a thread is exiting.
- In multithreaded mode, prevented memory corruption which could occur if the first thing that a thread performs when launched is to trigger a GC collection.
- Fixed incorrect generic conformance data when manipulating expanded generic types. For example, the following code:

      class A [G, H]
      feature
      	item: H
      end

      class C [G]
      end

      class ROOT_CLASS
      create
      	make
      feature
      	make is
      		local
      			l_a: A [STRING, expanded C [ANY]]
      		do
      			create l_a
      			io.put_string (l_a.item.generating_type)
      		end
      end

  would print

      expanded C [STRING]

  instead of

      expanded C [ANY]

- Fixed issue where you could get a bogus reference when trying to get a reference to the object associated to an ID (obtained through the IDENTIFIED class).

### .NET issues

- Fixed incorrect code generation of native arrays which would cause the code to be rejected in newer version of the .NET Framework.
- Fixed incorrect computation of `max_stack' for a routine body which could make the generated code not verifiable.

### Store/Retrieve issues

- Fix some issues related to the use of recoverable storable when manipulating generic types.