Object Orientation update

considered/rfc-oop-access.rst

@@ -0,0 +1,91 @@
+- Feature Name: Standard OOP model
+- Start Date: May 5th 2020
+- RFC PR:
+- RFC Issue:
+
+Summary
+=======
+
+Motivation
+==========
+
+Guide-level explanation
+=======================
+
+This capability is available to all types (including simple records). The idea
+here is to have an access type declared implicitely at the same level as the
+type and accessible through the 'Ref notation. An attribute 'Unchecked_Free is
+also declared, doing unchecked deallocation. 'Unchecked_Free can also be called
+directly on the object. For example:
+
+.. code-block:: ada
+
+   package P is
+      type T1 is tagged record
+         procedure P (Self : in out T1);
+
+         procedure P2 (Self : in out T1);
+      end T1;
+   end P;
+
+   procedure Some_Procedure is
+      V : T1'Ref := new T1;
+      V2 : T1'Ref := new T1;
+   begin
+      T1'Unchecked_Free (V);
+      V2'Unchecked_Free;
+   end Some_Procedure;
+
+For homogenity, 'Ref and 'Unchecked_Free are available to all Ada type -
+including pointers themsleves. It's now possible to write:
+
+.. code-block:: ada
+
+    V : T1'Ref'Ref := new T1'Ref;
+
+Contrary to tagged types, 'Ref access types for a given class object are
+compatible in the case of upcast, but need explicit conversions to downcast.
+You can write:
+
+.. code-block:: ada
+
+   package P is
+      type A is tagged record
+         procedure P (Self : in out T1);
+      end A;
+
+      type B is new T1 with record
+         procedure P (Self : in out T1);
+      end B;
+   end P;
+
+   procedure Some_Procedure is
+      A1 : A'Ref := new B;
+      A2 : A'Ref;
+
+      B1 : B'Ref := new B;
+      B2 : B'Ref;
+   begin
+      A2 := B1; -- OK, upcast, no need for pointer conversion
+      B2 := A1; -- Illegal, downcast
+      B2 := B'Ref (A1); -- OK, explicit downcast.
+   end Some_Procedure;
+
+Reference-level explanation
+===========================
+
+Rationale and alternatives
+==========================
+
+Drawbacks
+=========
+
+
+Prior art
+=========
+
+Unresolved questions
+====================
+
+Future possibilities
+====================

considered/rfc-oop-aggregates.rst

@@ -0,0 +1,168 @@
+- Feature Name: Standard OOP model
+- Start Date: May 5th 2020
+- RFC PR:
+- RFC Issue:
+
+Summary
+=======
+
+Motivation
+==========
+
+Guide-level explanation
+=======================
+
+In the presence of constructors, aggregates values are evaluated and assigned
+after the contructor is executed. So the full sequence of evaluation for
+fields of a class record is:
+
+- the constructor
+- any value from the aggregate
+
+This respects the fundamental rule that constructors can never be bypassed. For
+example:
+
+.. code-block:: ada
+
+   function Print_And_Return (S : String) return Integer is
+   begin
+      Put_Line (S);
+
+      return 0;
+   end;
+
+   type R1 is record
+      V, W : Integer := Print_And_Return ("Default");
+   end record;
+
+   type R2 is record
+      V, W : Integer := Print_And_Return ("Default");
+
+      procedure R2 (Self : in out R2);
+   end record;
+
+   V1 : R1 := (1, 2); -- prints Default Default
+   V2 : R2 := (1, 2); -- also prints Default Default
+
+This means that units compiled with the new version of Ada will have a specific
+backward incompatible change. Specifically, record initialized with an aggregate
+used to bypass default initialization, they would not anymore. From a
+functional standpoint, this would result in more code as well as different
+behavior if the default initialization has side effects. This can be fixed
+by offering constructors with the right parameters. These issues could be
+identified statically by migration tools.
+
+There is a specific question on performances impact, as the new semantic would
+evaluate default value where the current Ada semantic would not. This can be
+solved by not using default initialization in the type, but to provide instead
+a constructor that takes parameters to value all components. For example:
+
+.. code-block:: ada
+
+   type R1 is record
+      V, W : Integer := Some_Value;
+   end record;
+
+Can become:
+
+.. code-block:: ada
+
+   type R1 is record
+      V, W : Integer;
+
+      procedure R1 (Self : in out R1; V, W : Integer);
+   end record;
+
+   type body R1 is record
+      procedure R1 (Self : in out R1; V, W : Integer) is
+      begin
+         Self.V := V;
+         Self.W := W;
+      end R;
+   end record;
+
+As a consequence, writing:
+
+.. code-block:: ada
+
+   V1 : R1 := R1'Make(1, 2);
+
+Can be made compiled as efficiently as before (in particular if the constructors
+are inlined)
+
+In terms of syntax, in the presence of an implicit or explicit parameterless
+constructors, aggregates can be written as usual. The parameterless constructor
+will be called implicitly before modification of the values by the aggregate.
+
+If a non-parameterless constructor needs to be called, two syntaxes are available:
+- if only some values need to be modified, a delta aggregate can be used
+- if all values need to be modified, the syntax is "(<constructor call> with <values>)"
+  which is very close to the current notation for extension aggregates. For example:
+
+.. code-block:: ada
+
+   type R is record
+      V, W : Integer;
+
+      procedure R (Self : in out R);
+
+      procedure R (Self : in out R; V : Integer);
+   end record;
+
+   type R is record
+      procedure R (Self : in out R) is
+      begin
+         Put_Line ("Default");
+      end R;
+
+      procedure R (Self : in out R; V : Integer) is
+      begin
+         Put_Line (f"V = {V}");
+      end R;
+
+   end record;
+
+   V1 : R := (1, 2); -- prints "Default"
+   V2 : R := (R'Make (42) with delta V => 1); -- prints "V = 42"
+   V3 : R := (R'Make (42) with 1, 2);         -- also prints "V = 42"
+
+One of the consequences of the rules above is that it's not possible to use an
+aggregate within a constructor as it would create an infinite recursion:
+
+.. code-block:: ada
+
+   package P is
+      type T1 is tagged record
+         procedure T1 (Self : in out T1);
+
+	      A, B, C : Integer;
+      end T1;
+   end P;
+
+   package body P is
+      type body T1 is tagged record
+         procedure T1 (Self : in out T1) is
+         begin
+            Self := (1, 2, 3); -- infinite recursion
+         end T1;
+      end T1;
+   end P;
+
+Reference-level explanation
+===========================
+
+Rationale and alternatives
+==========================
+
+
+Drawbacks
+=========
+
+Prior art
+=========
+
+Unresolved questions
+====================
+
+Future possibilities
+====================

considered/rfc-oop-attributes.rst

@@ -0,0 +1,80 @@
+- Feature Name: Standard OOP model
+- Start Date:
+- RFC PR:
+- RFC Issue:
+
+Summary
+=======
+
+Motivation
+==========
+
+Guide-level explanation
+=======================
+
+Today, specifying a subprogram attribute of a type requires to declare a
+subprogram and then to use an aspect or an attribute to link it to a type, e.g.
+
+.. code-block:: ada
+
+   type T is null record;
+
+   for T'Write use My_Write;
+
+   procedure My_Write(
+      Stream : not null access Ada.Streams.Root_Stream_Type'Class;
+      Item : in T);
+
+This proposal allows to define directly the procedure as being an attribute of
+the type:
+
+.. code-block:: ada
+
+   type T is null record;
+
+   procedure T'Write(
+      Stream : not null access Ada.Streams.Root_Stream_Type'Class;
+      Item : in T);
+
+In addition, this can be used as a scoped attribute, possibly with re-ordering
+of parameters to ensure that the first parameter is conceptually the one
+"owning" the primitive, e.g.:
+
+.. code-block:: ada
+
+   type T is tagged record
+
+      procedure T'Write(
+         Stream : not null access Ada.Streams.Root_Stream_Type'Class;
+         Item : in T);
+
+   end T;
+
+This provide a seamless solution in particular to scope a destructor:
+
+
+.. code-block:: ada
+
+   type T is tagged record
+      procedure T'Destructor (Self : in out T);
+   end record;
+
+Reference-level explanation
+===========================
+
+Rationale and alternatives
+==========================
+
+Drawbacks
+=========
+
+Prior art
+=========
+
+Unresolved questions
+====================
+
+Future possibilities
+====================
+
+

considered/rfc-oop-body.rst

@@ -0,0 +1,50 @@
+- Feature Name: Standard OOP model
+- Start Date: May 5th 2020
+- RFC PR:
+- RFC Issue:
+
+Summary
+=======
+
+Motivation
+==========
+
+Guide-level explanation
+=======================
+
+One limitation of the tagged record to lift under this system is the ability to
+declare a primitives in the body of a package. As long as the type itself is
+also declared in the body, this should be legal:
+
+.. code-block:: ada
+
+   package body Pkg is
+      type T is tagged record
+         F : Integer;
+      end T;
+
+      procedure P (Self : in out T; V : Integer);
+
+      procedure P (Self : in out T; V : Integer) is
+      begin
+         Self.F := V;
+      end P;
+   end Pkg;
+
+Reference-level explanation
+===========================
+
+Rationale and alternatives
+==========================
+
+Drawbacks
+=========
+
+Prior art
+=========
+
+Unresolved questions
+====================
+
+Future possibilities
+====================