Qualified Name Scoping vs Class Member Scoping for struct members in language without block scope. Plus other questions (VS Code extension for existing SCL language)

[BjAlvestad]

In summary my questions is

For a language that:

• Does not have any block scope.
• Variables has to be defined in a fixed section at the top of the file (above where the logic section is).
  • Variables can be of simple types, or structs, or UDTs (UDTs are practically structs defined in a separate file).
• Accesses members of a struct with . between each level.

Would Qualified Name Scoping be sufficient here for setting up scoping/resolving of references for dot-members?
Or would it, even with the limitations in where the language can declare variables, be better to use Class Member Scoping?

Any suggestion with regards to how I ought to go about this would also be appreciated. Both from the side of grammar, and the overriding of the scope computation.

More information

Background and goal

I am a newbie with regards to language engineering. But I am interested in learning. My initial and current motivation is to create an extensions for VS Code to get things like auto complete and validation for an existing language (SCL, a Structured Text dialect, based on Pascal).
Aside from this, in the future, I am also thinking of creating an extension for auto-complete and validation of some configuration file formats. Maybe even making a DSL for a more convenient config language, and then compiling it down to the config format the equipment needs.

I am now trying to create a VS Code extension that will give auto-complete suggestions for variables etc.
Over time, I want to add validation, and showing comments as description for variables, show type etc. But for now my goal is just to get auto-complete to work.
Due to being on very thin ice, it would be nice to get some input from more knowledgeable people before I run too far in the wrong direction.

Using Langium, it was surprisingly easy to achieve auto-complete for variables declared on the top-most level. But I am unsure of the smartest way to start tackling access to child elements.
I made an attempt in the past where I went down the route of using Class Member Scoping based on the lox example, but I've discarded all I did from that point, and started over again now. Last time I made my grammar too specific, causing it to easily run into parsing errors. Also it was extremely slow when testing it on a large code base.

The language I am targeting

The language is SCL, which is a dialect of Structured Text for PLC programming.

Variable declaration

Variables are declared at the top of the file, before the program section starts. It is not possible to declare any variables in the program sections (below a BEGIN keyword).

The variables types declared will essentially be either:

• A simple type like BOOL or DINT etc.
• A STRUCT which then has variables defined inside that section.
• A UDT as eg "MyCustomDatatype", which practically is a struct defined in a separate file, where the block name inside the UDT file would be "MyCustomDatatype".
• A Function Block, where you could both access members (as a struct) or call the function block itself.

Member call

When calling members we access the local ones by starting with # and then the variable name.
For global ones are in double quotes, and the names of these are defined in a tag file.
E.g.

• #MyLocalVariable
• "MyGlobalVariable"
• #MyLocalStruct.myInnerVariable
• #MyLocalVariableFromUDT.myInnerVariable

My next goal now is to get linking / auto-complete for elements inside the struct, both when the struct is locally defined, and when it is referenced as a UDT in the declaration.
I do not focus on the global variable in double quotes at the moment, but I just mentioned it here, since it will have to be added in the future.

Target language example and my grammar

The grammar is not complete yet, and would probably benefit from several modifications.
E.g. Double quote variables will have to be supported everywhere the local # variables are, but this is not implemented yet.

I attach the grammar here for reference with relation to the question, and also in case someone would give some hints as to where I am heading in the right direction, and where I am veering heavily off course.

Target language

FB_MyTestDB_A.scl (click arrow to expand to see code)

FUNCTION_BLOCK "FB_MyTestFB_A"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      xboMyInput1A { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : BOOL;
      xboMyInput2A { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : Bool;   // Comment for xboMyInput2A
      xboMyInput3A : Bool;   // Comment for xboMyInput3A
      xiMyInput4A { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : DINT;
      xstiMyStringInputA { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : String;
   END_VAR

   VAR_IN_OUT 
      xyboMyInOut1A { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : Bool;   // Comment for xyboMyInOut1A
      xyboMyInOut2A { ExternalAccessible := 'False'; ExternalVisible := 'False'; ExternalWritable := 'False'} : Bool;   // Comment for xyboMyInOut2A
      xyuStatusObjectA : "U_Status";
   END_VAR

   VAR 
        uStatusObjectA : "U_Status";
        myStruct : STRUCT
            intenal1 : DINT;
            intenal2 : DINT;
            intenal3 : DINT;
            myInternal4NestedStruct : STRUCT
                nestedIntenal1 : DINT;
                nestedIntenal2 : DINT;
            END_STRUCT;
            intenal5 : DINT;
        END_STRUCT;
   END_VAR

   VAR_TEMP 
      tiMyTemp1A : DINT;
      myVar1 : DINT;
      myVar2 : DINT;
      myVar3 : DINT;
      myVar4 : DINT;
      myVar5 : DINT;
   END_VAR


BEGIN
    (*
        # Some block comment
        blah blah blah
    *)
    
    #tiMyTemp1A := xiMyInput4A;
    
    //**********************
    //****    Basics    ****
    //**********************
    
    #tiMyTemp1A := xiMyInput4A;
    #uStatusObjectA.good := TRUE;
    #uStatusObjectA.warning := #uStatusObjectA.good;

    IF xboMyInput1A THEN
        #tiMyTemp1A := xiMyInput4A;

        IF xboMyInput2A THEN
            #tiMyTemp1A := xiMyInput4A;
        END_IF;
    END_IF;

    IF #uStatusObjectA.good THEN
        #tiMyTemp1A := xiMyInput4A;
    ELSIF xboMyInput2A THEN
        #tiMyTemp1A := xiMyInput4A;
    ELSIF #myStruct.intenal1 THEN
        #tiMyTemp1A := xiMyInput4A;
    ELSIF xboMyInput2A THEN
        #tiMyTemp1A := xiMyInput4A;
    ELSE
        #tiMyTemp1A := xiMyInput4A;
    END_IF;

    CASE #xiMyInput4A OF
        1:
            #myVar1 := 11;
        2:
            #myVar2 := 22;
        3:
            #myVar2 := 23;
            #myVar3 := 33;
        4:
            #myVar4 := 44;
    END_CASE;

    CASE #xiMyInput4A OF
        xboMyInput1A:
            #myVar2 := 23;
            #myVar3 := 33;
        #xboMyInput2A,
        #xboMyInput3A:
            #myVar4 := 44;
        4:
            #myVar4 := 444;
    END_CASE;

    //**************************
    //****    Jump label    ****
    //**************************

    LocationsAlwaysVisible: //Jump label
    #myVar1 := 11;
    
    IF TRUE THEN
        GOTO LocationsAlwaysVisible;
    END_IF;
    
END_FUNCTION_BLOCK

U_Status.udt (click arrow to expand to see code)

TYPE "U_Status"
VERSION : 0.1
   STRUCT
      good : Bool;
      warning : Bool;
      fault : Bool;
      critical : Bool;
   END_STRUCT;

END_TYPE

My grammar so far

My grammar (click arrow to expand to see code)

grammar Scl
import "./scl-part-types"

entry Model:
    blockStart+=BlockStart
    (compilerDirective+=CompilerDirective)*
    (blockAttribute+=BlockAttribute)*
    (declarationSubSection+=DeclarationSubSection | vars+=VariableDeclaration)*
    ('BEGIN'
    (
        assignment+=Assignment
        | functionCalls+=FunctionCall
        | statementBlocks+=Statements
    )*)?
    BlockEnd;

Person:
    'person' name=ID;

Greeting:
    'Hello' person=[Person:ID] '!';

hidden terminal WS: /\s+/;
terminal ID: /[_a-zA-Z][\w_]*/;
terminal DOUBLE_QUOTE_STRING: /"(\\.|[^"\\])*"/;
terminal SINGLE_QUOTE_STRING: /'([^'])*'/;
terminal NUMBER returns number: /([DdLl]?[BbWwLl]#)?((16#[0-9a-fA-F_]+)|(((2|8)#)?[0-9-][0-9_]*(\.?[0-9eE_+-]+)?))/;

hidden terminal ML_COMMENT: /\(\*[\s\S]*?\*\)/;
hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;


CompilerDirective:
    '{'name+=ID ':=' value+=SINGLE_QUOTE_STRING (';' name+=ID ':=' value+=SINGLE_QUOTE_STRING)* ';'? '}';

BlockAttribute:
    ID '=' value=SINGLE_QUOTE_STRING
    | ID ':' value=(ID | SINGLE_QUOTE_STRING | NUMBER)
;

BlockStart:
    (
        'FUNCTION_BLOCK' |
        'FUNCTION' |
        'TYPE' |
        'DATA_BLOCK' |
        'ORGANIZATION_BLOCK'
    ) ( name=DOUBLE_QUOTE_STRING | name=ID) (':' type=(DataType | 'Void'))?;

VariableDeclaration:
    name=ID
    attributes+=VariableAttribute?
    ('AT' refName=[VariableDeclaration:ID])?
    ':'
    (isArray?='ARRAY' '[' arrayRange=ArrayRange ']' 'OF')?
    'REF_TO'? ((dataType=DataType) | dataTypeGlobal=[BlockStart:DOUBLE_QUOTE_STRING]) ((children+=VariableDeclaration)* 'END_STRUCT')?
    (assignment?=':=' value=Expression)?
    ';'
;

VariableAttribute:
    '{' (name=ID ':=' value=SINGLE_QUOTE_STRING ';'?)+ '}';

QualifiedName returns string:
    ID ('.' ID)*
;

// ***********************
// ****  Expressions  ****
// ***********************

Operator returns string:
    // Assignment
    ':=' | '=>' | '?=' | '+=' | '-=' | '*=' | '/=' | '**='
    // Addition
    '+' | '-'
    // Multiplication
    | '*' | '/' | '**' | 'MOD'
    // Logical
    | 'AND' | '&' | 'OR' | 'XOR'
    // Comparison
    | '<' | '<=' | '>' | '>=' | '=' | '<>'
;

ArrayRange:
    start+=Expression ('..' end+=Expression)? (',' start+=Expression ('..' end+=Expression)?)*
;

Expression:
    ((value+=NUMBER)* ('#' ref+=[VariableDeclaration:QualifiedName])* (looseRef+=QualifiedName)* (operator+=Operator)* ('(' args+=Expression (',' args+=Expression)* ')')*)*
;

FunctionCall:
    '#' var=[VariableDeclaration:QualifiedName] '(' args+=Expression (',' args+=Expression)* ')' ';'
;

Assignment:
    '#' var=[VariableDeclaration:QualifiedName] ':=' Expression ';'
;

Statements:
    IfStatement
    | ForStatement
    | WhileStatement
    | RepeatStatement
    | ContinueStatemen
    // | ReturnStatement  // Errors out with "Max call stack size exceeded" due to optional return value
    | ExitStatement
    | JumpLabel
    | ProgramJump
    | CaseLabel
    | CaseStatement
;

ExpressionBlock:
    Expression ';'
;

IfStatement:
    (('IF' | 'ELSIF') condition=Expression 'THEN')
    | 'ELSE'
    | ('END_IF' ';')
;

ForStatement:
    ('FOR' '#'? indexVariable=[VariableDeclaration:QualifiedName] '^'? ':=' initialValue=Expression 'TO' finalValue=Expression ('BY' execution=Expression)? 'DO')
    | ('END_FOR' ';')
;

WhileStatement:
    'WHILE' condition=Expression 'DO' |
    ('END_WHILE' ';')
;

RepeatStatement:
    'REPEAT' 
    | ('UNTIL' condition=Expression 'END_REPEAT' ';')
;

ContinueStatemen returns string:
    'CONTINUE' ';'
;

ReturnStatement:
    'return' value=Expression? ';'
;

ExitStatement returns string:
    'EXIT' ';'
;

JumpLabel:
    name=ID ':'
;

ProgramJump:
    'GOTO' jumpLabel=[JumpLabel:ID] ';'
;

CaseLabel:
    (('#' var+=[VariableDeclaration:QualifiedName]) | start+=NUMBER ('..' end+=NUMBER)?)
    (',' (('#' var+=[VariableDeclaration:QualifiedName]) | start+=NUMBER ('..' end+=NUMBER)?))*
    ':'
;

CaseStatement:
    'CASE' '#' var=[VariableDeclaration:QualifiedName] 'OF'
    | 'ELSE'
    | 'END_CASE' ';'
;

The separate scl-part-types file

This was just placed in a separate file to not clutter up the main file too much while working on it.

DeclarationSubSection returns string:
    'VAR_INPUT' | 'VAR_OUTPUT' | 'VAR_IN_OUT' | 'VAR' | 'VAR_TEMP' | 'CONST'
     | 'VAR' 'CONSTANT'
     | 'RETAIN' | 'NON_RETAIN'
     | 'END_VAR'
     | 'STRUCT'
     | 'END_STRUCT' ';'
;

DataType returns string:
    // Elementary types
    'BOOL'
    | 'BYTE' | 'WORD' | 'DWORD' | 'LWORD'  // LWORD is not not supported by S7-300
    | 'SINT' | 'INT' | 'DINT' | 'LINT' | 'USINT' | 'UINT' | 'UDINT' | 'ULINT'  // Only INT and DINT are supported by S7-300
    | 'REAL' | 'LREAL'
    | 'S5TIME' | 'TIME' | 'LTIME'
    | 'DATE'   | 'TIME_OF_DAY' | 'TOD' | 'LTOD' | 'LTIME_OF_DAY'
    | 'CHAR'  | 'WCHAR'
    // Complex - Struct
    | 'STRUCT'
    // Complex - Data and time
    | 'DT' | 'DATE_AND_TIME' | 'LDT' | 'DATE_AND_LTIME' | 'DTL'
    // String
    | 'WSTRING' | 'STRING'
;

// Declaration/assignment for elementary data types
fragment ElementaryType returns string:
    'BOOL'
    | 'BYTE' | 'WORD' | 'DWORD' | 'LWORD'  // LWORD is not not supported by S7-300
    | 'SINT' | 'INT' | 'DINT' | 'LINT' | 'USINT' | 'UINT' | 'UDINT' | 'ULINT'  // Only INT and DINT are supported by S7-300
    | 'REAL' | 'LREAL'
    | 'S5TIME' | 'TIME' | 'LTIME'
    | 'DATE'   | 'TIME_OF_DAY' | 'TOD' | 'LTOD' | 'LTIME_OF_DAY'
    | 'CHAR'  | 'WCHAR'
;

fragment DateAndTime returns string:
    'DT' | 'DATE_AND_TIME' | 'LDT' | 'DATE_AND_LTIME' | 'DTL'
;

BlockEnd returns string:
    'END_FUNCTION_BLOCK' |
    'END_FUNCTION' |
    'END_TYPE' |
    'END_DATA_BLOCK' |
    'END_ORGANIZATION_BLOCK'
;

[msujew]

Hey @BjAlvestad,

great question, I think we can probably do a better job at outlining the different uses cases in which you use FQN (fully qualified name) vs class member scoping. Right now the explanation is fairly technical with little pro & con arguments for each type of scoping.

Generally, I always try to recommend using class member scoping (assuming it is applicable), as there are multiple benefits to it compared to FQN scoping. These benefits are mainly concerning some LSP features like finding and going to references or stuff like auto completion. Most languages simply work better when using class member scoping. FQN scoping works best for languages that statically expose their elements under a fully qualified name. We mainly have the FQN guide for people migrating from Xtext, because FQN scoping is a builtin feature in Xtext, which also kind of inherited this from Java/EMF.

I think for ST/SCL, class member scoping would be the way to go. As for the grammar: I would recommend you to take a look at our lox language since it contains a full implementation of this kind of scoping.

[BjAlvestad]

Thank you very much for your quick response, pointing me in the right direction :)

I have re-written my grammar now to set it up for "Class Member Scoping", and will start to play around with getScope in DefaultScopeProvider to try and get an understanding of that.

My updated grammar (click arrow of toggle to expand)

grammar Scl
import "./scl-part-types"

entry Model:
    blockStart+=BlockStart
    (compilerDirective+=CompilerDirective)*
    (blockAttribute+=BlockAttribute)*
    (declarationSubSection+=DeclarationSubSection | vars+=VariableDeclaration)*
    ('BEGIN'
        (elements+=SclProgramElement)*
    )?
    ReturnStatement?
    BlockEnd
;

Person:
    'person' name=ID;

Greeting:
    'Hello' person=[Person:ID] '!';

hidden terminal WS: /\s+/;
terminal ID: /[_a-zA-Z][\w_]*/;
terminal DOUBLE_QUOTE_STRING: /"(\\.|[^"\\])*"/;
terminal SINGLE_QUOTE_STRING: /'([^'])*'/;
terminal NUMBER returns number: /([DdLl]?[BbWwLl]#)?((16#[0-9a-fA-F_]+)|(((2|8)#)?[0-9-][0-9_]*(\.?[0-9eE_+-]+)?))/;

terminal MEMORY_AREA: /%[XBWD]\d+/;

hidden terminal ML_COMMENT: /\(\*[\s\S]*?\*\)/;
hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;


CompilerDirective:
    '{'name+=ID ':=' value+=SINGLE_QUOTE_STRING (';' name+=ID ':=' value+=SINGLE_QUOTE_STRING)* ';'? '}';

BlockAttribute:
    ID '=' value=SINGLE_QUOTE_STRING
    | ID ':' value=(ID | SINGLE_QUOTE_STRING | NUMBER)
;

BlockStart:
    (
        'FUNCTION_BLOCK' |
        'FUNCTION' |
        'TYPE' |
        'DATA_BLOCK' |
        'ORGANIZATION_BLOCK'
    ) ( name=DOUBLE_QUOTE_STRING | name=ID) (':' type=(DataType | 'Void'))?;

VariableDeclaration returns NamedElement:
    {infer VariableDeclaration}
    name=ID
    attributes+=VariableAttribute?
    ('AT' refName=[NamedElement:ID])?
    ':'
    (isArray?='ARRAY' '[' arrayRange=ArrayRange ']' 'OF')?
    'REF_TO'? ((dataType=DataType) | dataTypeGlobal=[BlockStart:DOUBLE_QUOTE_STRING]) ((children+=VariableDeclaration)* 'END_STRUCT')?
    (assignment?=':=' value=Expression)?
    ';'
;

VariableAttribute:
    '{' (name=ID ':=' value=SINGLE_QUOTE_STRING ';'?)+ '}';

ArrayRange:
    start+=Expression ('..' end+=Expression)? (',' start+=Expression ('..' end+=Expression)?)*
;

// ***********************
// ****  Expressions  ****
// ***********************

SclProgramElement:
    Expression ';'
    | IfStatement
    | ForStatement
    | WhileStatement
    | RepeatStatement
    | ContinueStatemen
    | ExitStatement
    | JumpLabel
    | ProgramJump
    | CaseLabel
    | CaseStatement
;

Expression:
    Assignment
;

Assignment infers Expression:
    Addition ({infer BinaryExpression.left=current} operator=(':=' | '=>' | '?=' | '+=' | '-=' | '*=' | '/=' | '**=') right=Addition)*
;

Addition infers Expression:
    Multiplication ({infer BinaryExpression.left=current} operator=('+' | '-') right=Multiplication)*
;

Multiplication infers Expression:
    Logical ({infer BinaryExpression.left=current} operator=('*' | '/' | '**' | 'MOD') right=Logical)*
;

Logical infers Expression:
    Comparison ({infer BinaryExpression.left=current} operator=('AND' | '&' | 'OR' | 'XOR') right=Comparison)*
;

Comparison infers Expression:
    MemberCall ({infer BinaryExpression.left=current} operator=('<' | '<=' | '>' | '>=' | '=' | '<>') right=MemberCall)*
;

MemberCall infers Expression:
    Primary
	({infer MemberCall.previous=current} 
    // Member call with function call
        ("." '#'? element=[NamedElement:ID] '^'? (
		explicitOperationCall?='('
		(
		    arguments+=Expression (',' arguments+=Expression)*
		)?
		')')?
    // Array access on member
        | (
		explicitOperationCall?='['
		(
		    arguments+=Expression (',' arguments+=Expression)*
		)?
		']') 
    // Chained function call
        | (
		explicitOperationCall?='('
		(
		    parameters+=ID (':=' | '=>') arguments+=Expression
            (',' parameters+=ID (':=' | '=>') arguments+=Expression)*
		)?
		')')
        | ("." memoryArea=MEMORY_AREA)
        )
    )*
;

Primary infers Expression:
    '(' Expression ')'
    | UnaryExpression
    | NumberExpression
    | StringExpression
    | BooleanExpression
    | FeatureCall
    // | TimeExpression
;

FeatureCall infers Expression:
	{infer MemberCall}
	(functionCustom=Variable | functionBuiltin=BuiltInFunctionName)
    // Optional function call after referencing an element
    (explicitOperationCall?='('
	(
        parameters+=ID (':=' | '=>') arguments+=Expression
        (',' parameters+=ID (':=' | '=>') arguments+=Expression)*
	)?
	')')?;

GlobalVariable:
    var=[NamedElement:DOUBLE_QUOTE_STRING]
;

LocalVariable:
    '#' var=[NamedElement:ID]
;

Variable:
    GlobalVariable | LocalVariable
;

UnaryExpression:
    operator=('NOT' | '-' | '+') value=Expression
;

NumberExpression: value=NUMBER;
StringExpression: value=SINGLE_QUOTE_STRING;
BooleanExpression: value?='true' | 'false';

type NamedElement = VariableDeclaration;

IfStatement:
    (('IF' | 'ELSIF') condition=Expression 'THEN')
    | 'ELSE'
    | ('END_IF' ';')
;

ForStatement:
    ('FOR' indexVariable=Variable '^'? ':=' initialValue=Expression 'TO' finalValue=Expression ('BY' execution=Expression)? 'DO')
    | ('END_FOR' ';')
;

WhileStatement:
    'WHILE' condition=Expression 'DO' |
    ('END_WHILE' ';')
;

RepeatStatement:
    'REPEAT' 
    | ('UNTIL' condition=Expression 'END_REPEAT' ';')
;

ContinueStatemen returns string:
    'CONTINUE' ';'
;

ReturnStatement:
    'return' value=Expression? ';'
;

ExitStatement returns string:
    'EXIT' ';'
;

JumpLabel:
    name=ID ':'
;

ProgramJump:
    'GOTO' jumpLabel=[JumpLabel:ID] ';'
;

CaseLabel:
    ((var+=Variable) | start+=NUMBER ('..' end+=NUMBER)?)
    (',' ((var+=Variable) | start+=NUMBER ('..' end+=NUMBER)?))*
    ':'
;

CaseStatement:
    'CASE' var=Variable 'OF'
    | 'ELSE'
    | 'END_CASE' ';'
;

The separate scl-part-types file

DeclarationSubSection returns string:
    'VAR_INPUT' | 'VAR_OUTPUT' | 'VAR_IN_OUT' | 'VAR' | 'VAR_TEMP' | 'CONST'
     | 'VAR' 'CONSTANT'
     | 'RETAIN' | 'NON_RETAIN'
     | 'END_VAR'
     | 'STRUCT'
     | 'END_STRUCT' ';'
;

DataType returns string:
    // Elementary types
    'BOOL'
    | 'BYTE' | 'WORD' | 'DWORD' | 'LWORD'  // LWORD is not not supported by S7-300
    | 'SINT' | 'INT' | 'DINT' | 'LINT' | 'USINT' | 'UINT' | 'UDINT' | 'ULINT'  // Only INT and DINT are supported by S7-300
    | 'REAL' | 'LREAL'
    | 'S5TIME' | 'TIME' | 'LTIME'
    | 'DATE'   | 'TIME_OF_DAY' | 'TOD' | 'LTOD' | 'LTIME_OF_DAY'
    | 'CHAR'  | 'WCHAR'
    // Complex - Struct
    | 'STRUCT'
    // Complex - Data and time
    | 'DT' | 'DATE_AND_TIME' | 'LDT' | 'DATE_AND_LTIME' | 'DTL'
    // String
    | 'WSTRING' | 'STRING'
;

// Declaration/assignment for elementary data types
fragment ElementaryType returns string:
    'BOOL'
    | 'BYTE' | 'WORD' | 'DWORD' | 'LWORD'  // LWORD is not not supported by S7-300
    | 'SINT' | 'INT' | 'DINT' | 'LINT' | 'USINT' | 'UINT' | 'UDINT' | 'ULINT'  // Only INT and DINT are supported by S7-300
    | 'REAL' | 'LREAL'
    | 'S5TIME' | 'TIME' | 'LTIME'
    | 'DATE'   | 'TIME_OF_DAY' | 'TOD' | 'LTOD' | 'LTIME_OF_DAY'
    | 'CHAR'  | 'WCHAR'
;

fragment DateAndTime returns string:
    'DT' | 'DATE_AND_TIME' | 'LDT' | 'DATE_AND_LTIME' | 'DTL'
;

BlockEnd returns string:
    'END_FUNCTION_BLOCK' |
    'END_FUNCTION' |
    'END_TYPE' |
    'END_DATA_BLOCK' |
    'END_ORGANIZATION_BLOCK'
;

BuiltInFunctionName returns string:
    'SCATTER'
    | 'GATHER'
;

I guess I will see once I get a bit more understanding of the scope provider, if I will also se if I ought to rewrite the VariableDeclaration rule:

VariableDeclaration returns NamedElement:
    {infer VariableDeclaration}
    name=ID
    attributes+=VariableAttribute?
    ('AT' refName=[NamedElement:ID])?
    ':'
    (isArray?='ARRAY' '[' arrayRange=ArrayRange ']' 'OF')?
    'REF_TO'? ((dataType=DataType) | dataTypeGlobal=[BlockStart:DOUBLE_QUOTE_STRING]) ((children+=VariableDeclaration)* 'END_STRUCT')?
    (assignment?=':=' value=Expression)?
    ';'
;

I see Lox does it much cleaner with their Class. But on the other hand, I will need to support structs inside structs, and arrays of structs, whereas I presume Lox does not handle nested classes. So maybe the recursion I am doing to get inner structs (writing them to children) is a passable method?

[msujew]

So maybe the recursion I am doing to get inner structs (writing them to children) is a passable method?

Assuming it is the correct ST/SCL grammar, I think that's perfectly reasonable.