Top-level abstract clafer extending a nested abstract clafer

[ross2jd]

The is a feature request to allow extending nested abstract Clafers. Consider the following example:

abstract Person
    abstract Hand

abstract Hook : Hand

CptHook : Person
    left : Hook
    right : Hand

Currently, this code would not compile as Hook is not nested under Person. It would be nice to be able to say things like

abstract  Hook : Hand

So that large models can be broken into smaller pieces. Semantically this could work if when you had an abstract Clafer with inheritance it would also inherit the relation (if it exists) between the parent and the Clafer being inherited. I.e. in our example:

Person = {(root, _Person)}
Hand = {(_Person, _Hand)}
Hook = {(_Person, _Hook)}

[mantkiew]

My first stab at implementing it reveals a few problems, the biggest one being that I would have to change the analyses to always keep track of the whole inheritance hierarchy of a clafer to determine valid nesting and generate correct output. Currently, the code generated for left is incorrect:

one sig c0_CptHook extends c0_Person
{ r_c0_left : one c0_left
, r_c0_right : one c0_right }
{ r_c0_right in r_c0_Hand }

The correct code should be

one sig c0_CptHook extends c0_Person
{ r_c0_left : one c0_left
, r_c0_right : one c0_right }
{ r_c0_left in r_c0_Hand
  r_c0_right in r_c0_Hand }

The reason that the constraint r_c0_left in r_c0_Hand is missing now is because in order to generate it one must go up to Person, which defines Hand but we only go to Hook, which does not have a parent.

There's onc trick we could do: always interpret abstract top-level clafers which extend nested abstract clafers as actually their siblings. So, our example would actually be represented in IR as

abstract Person
    abstract Hand
    abstract Hook : Hand

that is the real semantics of allowing to define abstract Hook : Hand as a top-level. Doing so, will not require any changes to code analysis nor code generation. It's a simple transformation that can be done after unique ids are generated. The positive is that desugared clafer will show that semantics.

[mantkiew]

Implementation. We execute the transformation in two phases:

1. in ResolverInheritance.resolveNClafer, we change the parentUID of a top-level abstract clafers to point to the parent of their superClafer. This makes these clafers logically siblings of their super.
2. in ResolverInheritance.relocateTopLevelAbstractToParents, we physically move the top-level clafers to their respecitive parents. This makes these clafers physically siblings of their super.