Simplify mix-and-match INHERIT grammar (EXTEND keyword is superfluous)

[willend]

As mentioned by @g5t in #2062 - we ought to simplify the grammar sligtly:

(For edit near comp_share_inherit_extend: /* empty */)

This matches

SHARE
SHARE %{...%}
SHARE EXTEND %{...%}
making the EXTEND keyword superfluous.
Explicitly making the keyword optional (by ignoring its token, in the same way that comments are ignored) would simplify this repeated set of rules.

[farhi]

I do not think EXTEND is "superfluous". It has been there since 2001, and is well adopted by our users. In addition, in the current implementation of the grammar, it is indeed optional for adding codeblock in components, e.g.:

SHARE %{ ... %}
SHARE EXTEND %{ ... %}

are both supported. The 2nd syntax may seem odd indeed, but I guess it wont be used much, and simplifies the grammar with a recursive rule.
But

SHARE INHERIT blah EXTEND %{ ... %}

makes sense to me.
However

SHARE INHERIT blah %{ ... %}

is less meaningful.
So, in my view, we should go further with the COPY -> INHERIT grammar change.

[willend]

@farhi I think the point from @g5t is that we can do with an explicit grammar rule less? (i.e. simply "ignore" the EXTEND label in the component grammar)

I don't believe the point is be to suppress the explicit EXTEND %{%} rule for the instrument grammar - @g5t ?

[farhi]

OK, I see the point.
Indeed, very few users have implemented EXTEND in components (mostly me ?).

Then the EXTEND would be left only in the TRACE after component instances.
Agreed 👍

[g5t]

This is perhaps entirely motivated by the ANTLR4 syntax for matching grammars, which allows a set of rules like

declare: Declare multi_block;
share: UserVars multi_block;
initialise: Initialize multi_block;
...
multi_block: ((Inherit Identifier)|(Extend? unparsed_block))*;

with (Python) visitor methods

    def visitDeclare(self, ctx:McCompParser.DeclareContext):
        self.state.DECLARE(*self._multi_block(ctx.multi_block(), "declare"))

    def visitShare(self, ctx:McCompParser.ShareContext):
        self.state.SHARE(*self._multi_block(ctx.multi_block(), "share"))

    def visitInitialise(self, ctx:McCompParser.InitialiseContext):
        self.state.INITIALIZE(*self._multi_block(ctx.multi_block(), "initialize"))
...

that each use the same 'multi-block' visitor method

    def _multi_block(self, ctx: Parser.Multi_blockContext, part: str):
        """Common visitor for {part} ((COPY identifier)|(EXTEND? unparsed_block))*
        Ensures that the correct 'part' is pulled from named component definition(s)
        and that the definitions and new unparsed blocks are inserted in their given
        order.
        """
        blocks = dict()
        for ident in ctx.Identifier():
            comp = self.parent.get_component(str(ident))
            blocks[ident.getSourceInterval()[0]] = getattr(comp, part)
        for unparsed in ctx.unparsed_block():
            blocks[unparsed.getSourceInterval()[0]] = (self.visit(unparsed),)
        return [b for n in sorted(blocks.keys()) for b in blocks[n]]

which allows handling something complicated, like,

SHARE 
%{
// prepend something before the first parent
%} 
INHERIT parent1 
EXTEND 
%{
// add something between parents
%}
INHERIT parent 2
EXTEND
%{
// append something following the final parent
%}

using a single rule.

I think I can achieve the same by a slightly different rule

multi_block: unparsed_block? ((Inherit Identifier)|(Extend unparsed_block))*;

which enforces the concept that a first block is either 'bare', %{...%}, or inherited and all subsequent concatenated blocks are 'extensions' or further inherited.