Tutorial scenario day one: Hands-on xText, the logo turtle language

left 45
forward 15
right 90
forward 100

import "http://www.eclipse.org/emf/2002/Ecore" as ecore

LogoProgram :
    {LogoProgram}
    instructions+=Instruction (  instructions+=Instruction)*
    ;

Instruction :
    Forward | Left | Right  ;

Forward:
    'forward' steps=EInt;

Left :
    {Left}
    'left' angle=EInt;

Right :
    {Right}
    'right' angle=EInt;

EInt returns ecore::EInt:
    '-'? INT;

Instruction :
    Forward | Left | Right | ProcDeclaration ;

ProcDeclaration :
    {ProcDeclaration}
    'to'
    name=EString

        (  args+=Parameter)*
        (  instructions+=Instruction)*
    'end';

Parameter returns Parameter:
    {Parameter}
    ':'name=EString;
EString returns ecore::EString:
    STRING | ID;

Instruction :
    Forward | Left | Right | ProcDeclaration | ProcCall;
ProcCall :
    declaration=[ProcDeclaration|EString]
    '(' (actualArgs+=EInt)? ( "," actualArgs+=EInt)* ')'
    ;

    @Check
    def checkPassedParameters(ProcCall procCall){
        if(procCall.actualArgs.size != procCall.declaration.args.size){
            warning('invalid number of argument, (expecting '+procCall.declaration.args.size+')',
                procCall,
                LogoPackage.Literals.PROC_CALL__ACTUAL_ARGS
            )
        }
    }

    // quickfix API
            fragment = ui.quickfix.QuickfixProviderFragment2 {}

import static extension org.eclipse.xtext.EcoreUtil2.*

    @Fix(Diagnostic.LINKING_DIAGNOSTIC)
    def void fixMissingProcDecl(Issue issue,
                                IssueResolutionAcceptor acceptor) {
        if (issue.message.contains("ProcDeclaration")) {
            createMissingProcDecl(issue, acceptor);
        }
    }

    private def createMissingProcDecl(Issue issue, IssueResolutionAcceptor acceptor) {
        acceptor.accept(issue,
            "Create missing procedure declaration",
            "Create a new empty procedure declaration at the beginning of the file",
            null, // no icon
            [ element, context |
                val root = element.getContainerOfType(typeof(LogoProgram))
                root.instructions.add(
                    0,
                    LogoFactory::eINSTANCE.createProcDeclaration() => [
                        name = context.xtextDocument.get(issue.offset,
                        issue.length)
                    ]
                )
            ]
        );
    }

language = StandardLanguage {
            ...
            // formatter API
            fragment = formatting.Formatter2Fragment2 {}
}

class LogoFormatter extends AbstractFormatter2 {

    @Inject extension LogoGrammarAccess

    def dispatch void format(LogoProgram logoProgram, extension IFormattableDocument document) {
        for (instruction : logoProgram.instructions) {
            instruction.format
            instruction.append[setNewLines(1, 1, 2)]
        }
    }

    def dispatch void format(ProcDeclaration procDeclaration, extension IFormattableDocument document) {
        val to = procDeclaration.regionFor.keyword("to")
        val end = procDeclaration.regionFor.keyword("end")
        if(procDeclaration.args.empty) {
            val declName = procDeclaration.regionFor.feature(LogoPackage.Literals.PROC_DECLARATION__NAME).append[newLine]
            interior(declName, end)[indent]
        } else {
            for ( arg : procDeclaration.args) {
                arg.surround[oneSpace]
            }
            procDeclaration.args.last.append[newLine]
            interior(procDeclaration.args.last.regionFor.feature(LogoPackage.Literals.PARAMETER__NAME), end)[indent]
        }
        for (instruction : procDeclaration.instructions) {
            instruction.format
            instruction.append[setNewLines(1, 1, 2)]
        }
    }

    def dispatch void format(Block block, extension IFormattableDocument document) {
        val open = block.regionFor.keyword("[")
        val close = block.regionFor.keyword("]")
        open.append[newLine]
        interior(open, close)[indent]
        for (instruction : block.instructions) {
            instruction.format
            instruction.append[setNewLines(1, 1, 2)]
        }
    }

language = StandardLanguage {
            ...
            projectWizard = {
                generate = true
            }
            fileWizard = {
                generate = true
            }
}

language = StandardLanguage {
            ...
            qualifiedNamesProvider = {}
}

language = StandardLanguage {
            ...
            labelProvider = {
                generateStub = true
            }
}

class LogoGenerator extends AbstractGenerator {
    override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
        val List<ProcDeclaration> allProcDecl = resource.allContents.filter(ProcDeclaration).toList
        val content = '''
        <html>
            <body>
                List of procedures declared in «resource.URI.segments.last».
                «FOR procDecl : allProcDecl BEFORE '<UL>' AFTER '</UL>'»
                    <LI>«procDecl.name» («FOR arg : procDecl.args SEPARATOR ', '» «arg.name»«ENDFOR»)</LI>
                «ENDFOR»
            </body>
        </html>
        '''
        fsa.generateFile(resource.URI.segments.last+"_summary.html", content)
    }
}