Major changes between ISE Eiffel 5.4 and ISE Eiffel 5.5

    Contents
    1. What's new
    2. Improvements
    3. Changes
    4. Bug fixes
      1. Language issues
      2. Compiler issues
      3. Runtime/code generation issues
      4. .NET issues
      5. Store/Retrieve issues

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] ... endto 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 ANYby 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 endwould printexpanded C [STRING]instead ofexpanded 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.
1d8b9ba7-0609-b664-a4cf-16be1132b071