Наверное я неправильно что-то делаю с операторами, но следующая, можно сказать, тривиальная грамматика на моем ноуте компилируется три минуты:

    [PegGrammar(program, grammar {
    
        // character processing
        any                         = ['\u0000'..'\uFFFF'];
        newLine : void              = "\r\n" / '\n' / '\r' / '\u2028' / '\u2029' / '\u0085';
        comment                     = '#' (!newLine any)* newLine;
        space   : void              = ' ' / '\t' / '\u000B' / '\u000C' / comment;
        letter                      = ([Lu, Ll, Lt, Lm, Lo, Nl] / '_');
        digit                       = ['0'..'9'];
        
        
        // identifiers
        identifierPart              = letter / digit;
        identifierBody              = letter identifierPart*;
        identifier                  = identifierBody s;
        placeholder                 = '_' s;
        
        // spaces
        [InlineAllSubrules]
        s : void                    = space*;
        S : void                    = !identifierPart s;
        

        // string literal
        escapeSequence              = @"\""";
        simpleCharacter             = !( "\"" / "\\") any;
        character                   = escapeSequence / simpleCharacter;
        stringLiteral               = '"' character '"';

        // texty literals
        naLiteral                   = "~" S;
        trueLiteral                 = "true" S;
        falseLiteral                = "false" S;
        boolean                     = trueLiteral / falseLiteral; 
        
        // number literal
        naturalNumber               = digit+;
        integerNumber               = ('-' s)? naturalNumber s;
        decimalNumber               = integerNumber ("." naturalNumber)? ("e" naturalNumber)? s;
        
        
        // date literal
        datePart                    = ':'s naturalNumber s;
        date                        = naturalNumber s datePart+;
        
        
        // brackets
        parenL                      = '('s;
        parenR                      = ')'s;
        braceL                      = '['s;
        braceR                      = ']'s;
        bracketL                    = '{'s;
        bracketR                    = '}'s;
        
        
        // operators
        addOp                       = '+'s;
        subOp                       = '-'s;
        /**** и так далее ****/
        
        // punctuation
        comma                       = ','s;
        semicolon                   = ';'s;
        
        
        // names
        simpleName                  = identifier;
        complexName                 = simpleName? (nsOp simpleName)+;
        name                        = placeholder / simpleName / complexName;
        
        // values
        literalValue                = data / stringLiteral / boolean / listLiteral / date;
        value                       = name / literalValue;
        
        // expression lists
        commaList                   = expression (comma expression)*;
        semiList                    = expression (semicolon expression)*;
        
        // expressions        
        priorityExpression          = parenL expression parenR;
        ex0                         = priorityExpression //priorityExpression
                                    / value;
        
        callExpression              = ex0 parenL commaList parenR;
        indexExpression             = ex0 braceL commaList braceR;
        ex1                         = callExpression 
                                    / indexExpression 
                                    / ex0;
        
        memberExpression            = ex1 dotOp name;
        ex2                         = memberExpression
                                    / ex1;
        
        mapExpression               = ex2 mapOp ex3;
        reduceExpression            = ex2 reduceOp value reduceOp ex3 
                                    / ex2 reduceOp ex3;
        filterExpression            = ex2 filterOp ex3;
        pipeExpression              = ex2 pipeOp ex3;
        ex3                         = mapExpression 
                                    / reduceExpression 
                                    / filterExpression 
                                    / pipeExpression
                                    / ex2;
        
        powExpression               = ex3 powOp ex4;
        ex4                         = powExpression
                                    / ex3;
        
        mulExpression               = ex4 mulOp ex5;
        divExpression               = ex4 divOp ex5;
        ex5                         = mulExpression 
                                    / divExpression
                                    / ex4;
        
        addExpression               = ex5 addOp ex6;
        subExpression               = ex5 subOp ex6;
        ex6                         = addExpression 
                                    / subExpression
                                    / ex5;
        
        lessExpression              = ex6 lsOp ex7;
        lessEqualExpression         = ex6 lseOp ex7;
        greaterExpression           = ex6 gtOp ex7;
        greaterEqualExpression      = ex6 gteOp ex7;
        equalExpression             = ex6 eqOp ex7;
        ex7                         = equalExpression 
                                    / lessExpression 
                                    / lessEqualExpression 
                                    / greaterExpression 
                                    / greaterEqualExpression
                                    / ex6;
        
        orExpression                = ex7 orOp ex8;
        xorExpression               = ex7 xorOp ex8;
        andExpression               = ex7 andOp ex8;
        ex8                         = orExpression 
                                    / xorExpression 
                                    / andExpression
                                    / ex7;
        
        expression                  = ex8;
        
        
        // program structure
        statement : int             = expression;
        program : int               = statement+;
    })]

На этом же железе весь Немерле (DevBuildQuick) компилируется 5 минут. Я что-то неправильно делаю, или так и должно быть?

Cамое неприятное — что с интеграцией работать невозможно: она периодически подвисает (building types tree) на те же три минуты.