C>С конфигурацией IIS борюсь

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Reflection;

using Nemerle.Collections;
using Nemerle.Imperative;
using Nemerle.IO;
using Nemerle.Builtins.Function;
using Nemerle.Utility;

using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
//using Nemerle.Compiler.Typedtree;

using Nemerle.Assertions;

using TT = Nemerle.Compiler.Typedtree;
using TExpr = Nemerle.Compiler.Typedtree.TExpr;
using SCG = System.Collections.Generic;
using Debug = System.Diagnostics.Debug;

namespace Nemerle.Data.Linq
{
  /// <summary>
  /// Description of LinqSyntax.
  /// </summary>
  module LinqSyntax
  {
    internal LinqImpl(typer : Typer, expr : PExpr) : PExpr
    {
      match (expr)
      {
        | PExpr.Literal(Literal.String(_) as lit) => 
          ParseAndTranformLinqQuery(typer, expr.Location, lit.RawString)
          
        | PExpr.Call(PExpr.Member(PExpr.Literal(Literal.String(_) as lit) as litExpr, member) as obj, parms) => 
          // this section add support of "linq <# from ... #>.Sum()" syntax
          PExpr.Call(expr.Location, PExpr.Member(obj.Location, 
            ParseAndTranformLinqQuery(typer, litExpr.Location, lit.RawString), member), parms)
          
        | _ => 
          Message.Error(expr.Location, 
            "The 'linq' macro expect string literal with query code (try enclose query in round brackets)");
          <[ () ]>
      }
    }
    
    internal ParseAndTranformLinqQuery(typer : Typer, loc : Location, queryStrLiteral : string) : PExpr
    {
      unless (queryStrLiteral.StartsWith("<#"))
      {
        Message.Error(loc, "The 'linq' macro hould use recursive strinq (<#...#>)");
        return <[ () ]>;
      }
      
      Macros.DefineCTX(typer);
      
      def query = queryStrLiteral.Substring(2, queryStrLiteral.Length - 4);

      def (complMarkLine, complMarkChar) = 
        if (typer.Manager.IsCompletionInProgress)
          (typer.Manager.CompletionMarkLine, typer.Manager.CompletionMarkChar)
        else (-1, -1);

      def lexer = LexerLinq(typer, query, 
        Location(loc, loc.Line, loc.Column + 2, loc.EndLine, loc.EndColumn),
        complMarkLine, complMarkChar);
      
      def expectKeyword(keywordName : string) : void
      {
        def tok = lexer.GetAnyToken();
        
        match (tok)
        {
          | Token.Operator(x) when x == keywordName => () //It's OK!
          | Token.Keyword(x)  when x == keywordName => () //It's OK!
          | _ => 
            Message.Error(tok.Location, $"expected keyword $keywordName but found '$tok'");
            throw ParseErrorException();
        }
      }
      def tryExpectKeyword(keywordName : string) : bool
      {
        def tok = lexer.GetAnyToken();
        
        match (tok)
        {
          | Token.Operator(x) when x == keywordName
          | Token.Keyword(x)  when x == keywordName => true //It's OK!
          | _ => 
            Message.Error(tok.Location, $"expected keyword $keywordName but found '$tok'");
            false
        }
      }
      def tryParseKeyword[T](keyword : string, sucsessContinuation : void -> T, failValue : T) : T
      {
        match (lexer.Peek())
        {
          | Token.Keyword(kwd) when kwd == keyword => 
            _ = lexer.GetAnyToken();
            sucsessContinuation()
          
          | _ => failValue
        }
      }
      def tryPeekAnyToken(tokenName : string) : bool
      {
        def tok = lexer.GetAnyToken();
        lexer.PushBack(tok);
        
        match (tok)
        {
          | Token.Comma with x = ","
          | Token.Operator(x) 
          | Token.Keyword(x)  
          | Token.Identifier(x) => x == tokenName
          | _ => false
        }
      }
      def parseIdentifier() : Name
      {
        def tok = lexer.GetAnyToken();
        
        match (tok)
        {
          | Token.Identifier(name) as tok => Name(name, tok.Location) //It's OK!
          | _ => 
            Message.Error(tok.Location, $"expected identifier but found '$tok'");
            throw ParseErrorException();
        }
      }
      def parseExpr() : PExpr
      {
        def expr = MainParser.ParseExpr(lexer.Env, lexer, false);
        expr
      }
      def parseFromClause(first) : QueryClause.From
      {
        expectKeyword("from");
        def paramName = parseIdentifier();
        expectKeyword("in");
        def expr = parseExpr();
        QueryClause.From(first + expr.Location, paramName, expr)
      }
      def parseSelectClause(first) : QueryClause.Select
      {
        expectKeyword("select");
        def expr = parseExpr();
        QueryClause.Select(first + expr.Location, expr)
      }
      def parseLetClause(first) : QueryClause.Let
      {
        expectKeyword("let");
        def paramName = parseIdentifier();
        expectKeyword("=");
        def expr = parseExpr();
        QueryClause.Let(first + expr.Location, paramName, expr)
      }
      def parseWhereClause(first) : QueryClause.Where
      {
        expectKeyword("where");
        def expr = parseExpr();
        QueryClause.Where(first + expr.Location, expr)
      }
      def parseJoinClause(first) : QueryClause.Join
      {
        expectKeyword("join");
        def ident = parseIdentifier();
        expectKeyword("in");
        def inExpr = parseExpr();
        def (loc, key1Expr, key2Expr, into) = if (tryExpectKeyword("on"))
        {
          def keyExprs = parseExpr();
          def (key1Expr, key2Expr) = match (keyExprs)
          {
            | <[ $key1Expr == $key2Expr ]> => (key1Expr, key2Expr)
            | _ =>
              Message.Error(keyExprs.Location, "expected key1 == key2 expression");
              (keyExprs, <[ () ]>)
              //throw ParseErrorException();
          }
          def into = tryParseKeyword("into", () => Some(parseIdentifier()), None());
          def last = match (into) { | Some(x) => x.Location | _ => key2Expr.Location };
          (first + last, key1Expr, key2Expr, into)
        }
        else (first + inExpr.Location, <[ () ]>, <[ () ]>, None());

        QueryClause.Join(loc, ident, inExpr, key1Expr, key2Expr, into)
      }
      def parseOrderClause(first) : QueryClause.Orderby
      {
        def parseOrderings() : list[PExpr * bool]
        {
          def expr = parseExpr();
          def ascending1 =                 tryParseKeyword("desc",       () => false, true);
          def ascending2 = if (ascending1) tryParseKeyword("descending", () => false, true) // C# syntax
                           else false;
          def ascending3 = if (ascending2) tryParseKeyword("ascending",  () => true,  true) // C# syntax
                           else false;
          
          if (tryPeekAnyToken(","))
          {
            _ = lexer.GetAnyToken();
            (expr, ascending3) :: parseOrderings()
          }
          else (expr, ascending3) :: []
        }
        unless (tryParseKeyword("order", () => { expectKeyword("by"); true }, false))
          expectKeyword("orderby");
        def orderings = parseOrderings();
        def last = if (orderings.IsEmpty) lexer.Location else orderings.Last[0].Location;
        QueryClause.Orderby(first + last, orderings)
      }
      def parseGroupClause(first) : QueryClause.Group
      {
        expectKeyword("group");
        def expr = parseExpr();
        expectKeyword("by");
        def byExpr = parseExpr();
        QueryClause.Group(first + byExpr.Location, expr, byExpr)
      }
      def parseQueryBody() : list[QueryClause]
      {
        def tok = lexer.Peek();
        def first = tok.Location;
        def clause = match (tok)
          {
            | Token.Keyword("from")   => parseFromClause(first)
            | Token.Keyword("select") => parseSelectClause(first)
            | Token.Keyword("let")    => parseLetClause(first)
            | Token.Keyword("where")  => parseWhereClause(first)
            | Token.Keyword("join")   => parseJoinClause(first)
            | Token.Keyword("orderby")
            | Token.Keyword("order")  => parseOrderClause(first)
            | Token.Keyword("group")  => parseGroupClause(first)
            | Token.Keyword("into")   => parseIntoClause(first)
            | Token.EndOfFile => null
            | _ => null 
              //TODO: Add error report
          };
          
        def res = if (clause == null) []
                  else clause :: parseQueryBody();
        res
      }
      and parseIntoClause(first) : QueryClause.Into
      {
        expectKeyword("into");
        def ident = parseIdentifier();
        QueryClause.Into(first + ident.Location, ident)
      }
      def convertQuery(collection : PExpr, queryClauses : list[QueryClause], parms : SCG.List[PExpr]) : PExpr
      {
        def make_x_param(parms : SCG.List[PExpr]) : PExpr
        {
          assert2(!parms.IsEmpty());
          if (parms.Count == 1) parms[0] else PExpr.Tuple(NList.ToList(parms), 1)
        }
        def appendArgToTuple(paramExpr, exprForAppend) : PExpr.Tuple
        {
          match (paramExpr)
          {
            | PExpr.Tuple(args) => PExpr.Tuple.Create(args + [exprForAppend])
            | _                 => PExpr.Tuple.Create([paramExpr, exprForAppend])
          }
        }
        match (queryClauses)
        {
          | QueryClause.From(ident1, inExpr1) :: QueryClause.From(ident2, inExpr2) :: QueryClause.Select(selExpr) :: tail 
          | QueryClause.From(ident1, inExpr1) :: QueryClause.From(ident2, inExpr2) :: tail with selExpr = null =>
            // from x1 in e1 from x2 in e2 ==> e1.SelectMany( x1 => e2 , ( x1 , x2 ) => new { x1 , x2 } )
            def p1 = <[ $(ident1 : name) ]>;
            def p2 = <[ $(ident2 : name) ]>;
            parms.Add(p1);
            parms.Add(p2);
            
            def selExpr2 = if (selExpr == null) <[ ($p1, $p2) ]> else selExpr;
            
            def newCollection = <[ $inExpr1.SelectMany($p1 => $inExpr2,  (($p1, $p2)) => $selExpr2) ]>;
            convertQuery(newCollection, tail, parms)
          
          | QueryClause.From(ident, inExpr) :: tail => 
            parms.Add(<[ $(ident : name) ]>);
            convertQuery(inExpr, tail, parms)
            
          | QueryClause.Where(expr) as clause :: tail =>
            // from x in e
            // where f
            // from x in ( e ) . Where ( x => f )
            def e = collection;
            def x = make_x_param(parms);
            def newCollection = Util.locate(clause.Location, <[ $e.Where($x => $expr) ]>);
            convertQuery(newCollection, tail, parms)

          | QueryClause.Select(expr) :: tail =>
            //TODO: Тут надо как-то извлекать список имен колонок и копировать его в parms
            def x = make_x_param(parms);
            def newCollection = <[ $collection.Select($x => $expr) ]>;
            convertQuery(newCollection, tail, parms)
            
          | QueryClause.Join(ident, inExpr, k1, k2, into) :: tail =>
            // from x1 in e1    join x2 in e2 on k1 equals k2 
            def e1 = collection;
            def e2 = inExpr;
            def x1 = make_x_param(parms);
            def x2 = <[ $(ident : name) ]>;
            def newCollection = match (into)
            {
              | Some(intoName) => 
                def g = <[ $(intoName : name)]>;
                parms.Add(g);
                // e1.GroupJoin(e2 , x1 => k1, x2 => k2, (x1, g) => new { x1 , g })
                def x1_g = appendArgToTuple(x1, g);
                <[ $e1.GroupJoin($e2, $x1 => $k1, $x2 => $k2, ($x1, $g) => $x1_g) ]>;
                
              | None => 
                parms.Add(x2);
                // from * in (e1).Join(e2, x1 => k1, x2 => k2, (x1, x2) => new { x1 , x2 })
                def x1_x2 = appendArgToTuple(x1, x2);
                <[ $e1.Join($e2, $x1 => $k1, $x2 => $k2, ($x1, $x2) => $x1_x2) ]>;
            };
            convertQuery(newCollection, tail, parms)
            
          | QueryClause.Let(ident, expr) :: tail =>
            // from x in e  
            // let y = f
            // from * in ( e ) . Select ( x => new { x , y = f } )
            def e = collection;
            def x = make_x_param(parms);
            def x_f = appendArgToTuple(x, expr);
            def newCollection = <[ $e.Select($x => $x_f) ]>;
            parms.Add(<[ $(ident : name) ]>);
            convertQuery(newCollection, tail, parms)
            
          | QueryClause.Orderby([]) as o :: tail =>
            Message.Error(o.Location, "a orderby clause should contains one or more orderings");
            convertQuery(collection, tail, parms)

          | QueryClause.Orderby((ordExpr, direction) :: tailOrderings) :: tail =>
            // from x in e   orderby k1 , k2 , … , kn  ==>
            // e.OrderBy(x => k1).ThenBy(x => k2). … .ThenBy(x => kn)
            
            def e = collection;
            def x = make_x_param(parms);
            // e.OrderBy(x => k1)
            def newCollection1 = if (direction) <[ $e.OrderBy          ($x => $ordExpr) ]>
                                 else           <[ $e.OrderByDescending($x => $ordExpr) ]>;
            // .ThenBy(x => k2). … .ThenBy(x => kn)
            def convertTailOrderings(x : PExpr, orderings, e : PExpr) : PExpr
            {
              match (orderings)
              {
                | (ordExpr, direction) :: tail =>
                  def new_e = if (direction) <[ $e.ThenBy          ($x => $ordExpr) ]>
                              else           <[ $e.ThenByDescending($x => $ordExpr) ]>;
                  convertTailOrderings(x, tail, new_e)
                  
                | [] => e
              }
            }            
            def newCollection2 = convertTailOrderings(x, tailOrderings, newCollection1);
                                
            convertQuery(newCollection2, tail, parms)
            
          | QueryClause.Group(expr, byExpr) :: tail =>
            // from x in e group v by k
            // e.GroupBy(x => k, x => v)   ||   e.GroupBy(x => k) WHERE v is x
            def e = collection;
            def x = make_x_param(parms);
            def v = expr;
            def k = byExpr;
            def newCollection = <[ $e.GroupBy($x => $k, $x => $v) ]>;
            //TODO: Implement: e.GroupBy(x => k) WHERE v is x
            convertQuery(newCollection, tail, parms)
            
          | QueryClause.Into(ident) :: tail =>
            // from … into x … 
            // from x in ( from … ) …

            // reset all params and add new one (x)
            def newParms = SCG.List();
            newParms.Add(<[ $(ident : name) ]>);
            // try continue convertions
            convertQuery(collection, tail, newParms);
          
          | [] => collection
          | queryClaus :: _ => 
            def clausName = queryClaus.GetType().Name.ToLower();
            Message.Error(queryClaus.Location, $"clause '$clausName' not supported yet");
            collection
        }
      }
      def parseQuery() : list[QueryClause]
      {
        def from = parseFromClause(lexer.Location);
        def queryBody = parseQueryBody();
        def query = from :: queryBody;
        query
      }
      
      typer.Env.Manager.MacroColors.PushUseSiteColor();
      try { convertQuery(null, parseQuery(), SCG.List()) }
      catch { | _ => <[ () ]> }
      finally { typer.Env.Manager.MacroColors.PopColor(); }
    }
  }
}

C>Строки подсвечиваются, и обычные, и рекурсивные, но вот заметить коричневый цвет на синем фоне сложно

 Message.Error(tok.Location, $"expected keyword $keywordName but found '$tok'");

def q = <#
my string
#>;
def p = linq <# from i in a select i #>;
def u = "string";

using System.Console;
using Nemerle.Diagnostics;

module Program
{
  Main() : void
  {
    def source = "test ";
    mutable str = "";

    time 
      repeat(40_000)
        str += source;

    WriteLine($"Size: $(str.Length)");
  }
}

static Main() : void
    WriteLine($"Hello, $username")

match (currentPExpr.TypedObject)
{
  | TExpr.Xxx => анализиурем информацию о типах для получения подсветки, ссылок и подсказок.
  ...
}

C>static Main() : void
C>    WriteLine($"Hello, $username")
C>

def x = <[
   decl:
     1
 ]>;

def x = <[
   parameter:
     1
 ]>;

Такой префикс называется «типом цитирования». Вот полный список типов цитирования:

* decl – декларация верхнего уровня. Тип или член типа.
* fundecl – декларация локальной функции.
* case – вхождение оператора match.
* parameter – описание параметра функции.
* ttype – «типизированная» ссылка на тип. При его использовании цитата должна содержать ссылку на тип. Допустима частичная квалификация (с учетом открытых в месте объявления пространств имен).