Embed typescript fragments inside your dsl

[nadavhames]

Here is the rough idea: It would be quite cool if it were possible to specify inside your grammar that part of a rule can be a valid typescript expression/function/value/etc. That way, you could make DSLs that intermix your custom grammar and TS fragments:

thing Other {
  type String
}

thing Foo {
    description "A cool thing that does stuff"
    dependency Other
    type Number
    compute (other: String): Number => {     // Hey look, its a TS function embedded inside our dsl!
       .... ts calculations ....             // It is smart enough to require the correct function signature
       return 100                              
    }
}

• In the small example use case above, we expect in our grammar that the next thing after compute is a typescript function with arguments being the dependencies we have added to our thing and the return type is the type we have specified in our thing.
• Inside the typescript fragment, we could switch over to typescript's completion and somehow pass it the function args/signature/return type we are expecting to get the usual ts editor intellisense you would get if you were in a regular ts file. Regarding code gen of the dsl to typescript, no generation is required for these blocks, it would be mainly a copy paste job to the correct location in the generated impl.
• I am not sure how feasible this would be, but maybe this is in the realm of possibility since the project itself is written in typescript.

[msujew]

Hey @nadavhames, what this effectively requires are two parts:

1. Handle TS code inside of { } as it if were a single token, making Langium ignore its contents. Alternatively, implement a TypeScript like syntax in a Langium grammar. This improves stuff like error recovery, but is obviously more complicated.
2. Invoke the TypeScript library API (imported via the typescript package) on the provided text snippet and proxy all LSP requests to the TypeScript library instead of letting Langium handle it.

I think this should be doable, though the second part requires a lot of intervention on pretty much all LSP services.

[nadavhames]

Regarding 1, I would even say that this whole block would constitute a ts function:

(other: String): Number => {     
       .... ts calculations .... 
       return 100                              
}

• We could surround the whole thing in """ """ or something instead to get the single token ignore behavior as you describe.
• Would also be nice to have a customizable lsp type provider that passes relevant info to the TS lsp based on what you have written so far in the dsl so that the text snippet has accurate autocomplete with type information.

TypescriptFucntion: '"""' ignore all the stuff in here '"""'
Computation: 'compute' TypescriptFunction

And then somewhere else we have something that provides the ts lsp with type info that gets prefixed to whatever typescript the user will write in the snippet:

export function typescriptLSPProvider(model: Model, tsStatement: Stmt): string {
    // examine the ast however you need to output the following:
   return "type Compute = (other: String) => Number; let fn: Compute = <user's cursor placed here would get the completion from Compute type>"
}

[suerta-git]

Hi @nadavhames, may I know what business your DSL is designed for? because I am planning to build an in-house DSL but I found that your DSL's grammar is very similar with the thing in my mind.