-
|
Tag: @msujew Example Project: Entities DSL Repo I'm attempting to implement a custom formatter by extending the AbstractFormatter as shown in the Domain example. The formatter should insert two newlines after each Example Text: entity MyFirstEntity {
string s;
int[10] a;
}
entity MySecondEntity extends MyFirstEntity {
MyFirstEntity e;
}import { AbstractFormatter, Formatting } from 'langium';
import * as ast from './generated/ast';
export class EntitiesFormatter extends AbstractFormatter {
protected format(model: ast.Model): void {
const lastEntity = model.entities[model.entities.length - 1];
model.entities.forEach(entity => {
const formatter = this.getNodeFormatter(entity);
const node = formatter.node(entity);
if (entity === lastEntity) {
node.append(Formatting.newLine());
} else {
node.append(Formatting.newLines(2));
}
});
}
}Invoking the format command in VSCode using While intuitively I assume it's complaining about trying to read the array length, I'm not sure how I would implement it differently. |
Beta Was this translation helpful? Give feedback.
Replies: 3 comments 8 replies
-
|
Tag: @msujew Disregard - I'll leave this here in case anyone else is curious. I'm assuming that since we don't have dynamic dispatch (Xtend) that means that we have to call protected format(node: AstNode): void {
if (ast.isModel(node)) {
const lastEntity = node.entities[node.entities.length - 1];
node.entities.forEach(entity => {
const formatter = this.getNodeFormatter(entity);
const node = formatter.node(entity);
if (entity === lastEntity) {
node.append(Formatting.newLine());
} else {
node.append(Formatting.newLines(5));
}
});
}
} |
Beta Was this translation helpful? Give feedback.
-
|
Hey, great that you were able to resolve the issue :) You're right, that the Also, I've been planning to document the formatting feature (or rather: write a guide on it), but didn't have the time yet. I'm currently trying to push the documentation forward, so there probably will be some progress in the coming weeks. |
Beta Was this translation helpful? Give feedback.
-
|
This seems to be mostly working. For some add'l context - this is what I'm trying to "port" for lack of better words: class EntitiesFormatter extends AbstractFormatter2 {
@Inject extension EntitiesGrammarAccess
def dispatch void format(Model model, extension IFormattableDocument document) {
val lastEntity = model.entities.last
for (entity : model.entities) {
entity.format
if (entity === lastEntity)
entity.append[setNewLines(1)]
else
entity.append[setNewLines(2)]
}
}
def dispatch void format(Entity entity, extension IFormattableDocument document) {
entity.regionFor.keyword("extends").surround[oneSpace]
entity.regionFor.feature(ENTITY__NAME).surround[oneSpace]
entity.regionFor.feature(ENTITY__SUPER_TYPE).surround[oneSpace]
val open = entity.regionFor.keyword(entityAccess.leftCurlyBracketKeyword_3)
val close = entity.regionFor.keyword("}")
open.append[newLine]
interior(open, close)[indent]
for (attribute : entity.attributes) {
attribute.type.format(document)
attribute.regionFor.keyword(";").surround[noSpace]
attribute.append[setNewLines(1, 1, 2)]
}
}
def dispatch void format(AttributeType attributeType, extension IFormattableDocument document) {
if (!attributeType.array) {
attributeType.elementType.append[oneSpace]
} else {
attributeType.regionFor.keyword("[").surround[noSpace]
attributeType.regionFor.keyword("]").prepend[noSpace].append[oneSpace]
}
}
}export class EntitiesFormatter extends AbstractFormatter {
protected format(node: AstNode): void {
if (ast.isModel(node)) {
const lastEntity = node.entities[node.entities.length - 1];
node.entities.forEach(entity => {
const formatter = this.getNodeFormatter(entity);
const node = formatter.node(entity);
if (entity === lastEntity) {
node.append(Formatting.newLine());
} else {
node.append(Formatting.newLines(2));
}
});
} else if (ast.isEntity(node)) {
const formatter = this.getNodeFormatter(node);
formatter.keyword("extends").surround(Formatting.oneSpace());
// entity name
// entity superType
const bracesOpen = formatter.keyword("{");
const bracesClose = formatter.keyword("}");
bracesOpen.append(Formatting.newLine());
formatter.interior(bracesOpen, bracesClose).prepend(Formatting.indent());
node.attributes.forEach(attribute => {
const formatter = this.getNodeFormatter(attribute.type);
const node = formatter.node(attribute);
formatter.keyword(";").surround(Formatting.noSpace());
node.append(Formatting.newLine());
});
} else if (ast.isAttributeType(node)) {
const formatter = this.getNodeFormatter(node);
if (!node.array) {
const elem = formatter.node(node.entity);
elem.append(Formatting.oneSpace());
} else {
formatter.keyword("[").surround(Formatting.noSpace());
formatter.keyword("]").prepend(Formatting.noSpace()).append(Formatting.oneSpace());
}
}
}
} |
Beta Was this translation helpful? Give feedback.
-
Any particular issues that you're noticing? The formatting stuff is missing automated tests, so there might be a few issues in there. The API also might not be the most intuitive... |
Beta Was this translation helpful? Give feedback.
-
|
Well, it's definitely wonky - but I'm not 100% sure that it's not my implementation. For instance, the formatting will oscillate on repeated format invocations (i.e., right now it looks better if I format it twice). Since there is a single entry point through the I believe it should be repeatable if you were inclined to pull that example repo down and build/run it. I'll play with it some more ... it seemed like some of the prepend/append formatting for newlines and indents was unpredictable. I'll note anything I find and open an issue if I can see it's clearly borked. Luckily the next section in this book is on automated testing for the formatting. :) ... or not. Just discovered the utility of the helper classes you guys create. Figuring out how to parse text into AstNodes and emulate a LSP call to the service is a bit beyond my skillset (if that's even how it's done). |
Beta Was this translation helpful? Give feedback.
-
Luckily, that's not even necessary. You can relatively easily create your own test method for this: You just need the |
Beta Was this translation helpful? Give feedback.
-
|
See #626 |
Beta Was this translation helpful? Give feedback.
-
|
Tag: @msujew I'll just tag this here ... working through some example parser unit tests and what seems like a straightforward object equality check results in a heap error. It's not completely obvious to me why this explodes ... Grammar:Unit Test ( ... this goes boom ... ):test('Parse: VariableReference', async () => {
const text=`
var i = 10
eval i`;
const parse = await helper(text);
const elements = parse.parseResult.value.elements;
expect((elements[elements.length - 1].expression as VariableRef).variable).toEqual(elements[0]);
}); Note: As a work around (which I think accomplishes the intent of testing the reference), I used the following, which seemed to work. expect((elements[elements.length - 1].expression as VariableRef).variable.ref?.name).toBe('i') |
Beta Was this translation helpful? Give feedback.
-
|
I believe the issue is that jest performs a naive deep quality comparison with |
Beta Was this translation helpful? Give feedback.
-
|
Tag: @msujew Thanks so much for taking all this time to respond! Just start signing me up for easy bugs to fix or documentation so I can repay you guys for all of the education. So that makes sense (I think). Just to make sure I'm following ... These unit tests are all originally written in Xtend ... so in that case they are most likely evaluating true object equality. I'm guessing that Xtext must be smart enough to resolve the declared variable token and the variable reference token to the same AST object (or something along those lines ... sounds close enough). Using Langium, they are separate, bi-directionally linked elements ... so true equality (naive?) will never resolve. In that case, testing for correct reference is more appropriate (i.e. the workaround-actually-most-likely-correct test I wrote). On the topic of porting Xtend tests to Jest ... which is more difficult than I anticipated ... Any thoughts on this? I'm trying to replicate an associativity test for the same test repo I linked above. I apologize in advance for the length of this, it really didn't start off this long ... it ended up being a stream of consciousness. Grammar:As best I can tell, the Xtend unit test (shown below) is doing the following:
Xtend Associativity Test (partial): @Test
def void testPlus() {
"10 + 5 + 1 + 2".assertRepr("(((10 + 5) + 1) + 2)")
}
def private String stringRepr(Expression e) {
switch (e) {
Plus: '''(«e.left.stringRepr» + «e.right.stringRepr»)'''
IntConstant: '''«e.value»'''
StringConstant: '''«e.value»'''
BoolConstant: '''«e.value»'''
VariableRef: '''«e.variable.name»'''
}.toString
}
def private assertRepr(CharSequence input, CharSequence expected) {
("eval " + input).parse => [
expected.assertEquals(elements.last.expression.stringRepr)
]
}So, I took a shot at doing this using Langium: Langium Associativity Testimport { parseHelper } from 'langium/test';
import * as ast from '../language-server/generated/ast';
import { createExpressionsServices } from '../language-server/expressions-module';
const services = createExpressionsServices().Expressions;
const helper = parseHelper<ast.ExpressionsModel>(services);
describe('Expressions Parser', () => {
it('should have associative addition', async () => {
const input = `(((10 + 5) + 1) + 2)`;
const expected = `10 + 5 + 1 + 2`;
expect(assertRepr(input)).resolves.toBe(expected);
});
function stringRepr(e: ast.Expression): string {
switch (e.$type) {
case ast.Plus: return `(${stringRepr((e as ast.Plus).left)} + ${stringRepr((e as ast.Plus).right)})`;
case ast.IntConstant: return `${(e as ast.IntConstant).value}`;
case ast.StringConstant: return `${(e as ast.StringConstant).value}`;
case ast.BoolConstant: return `${(e as ast.BoolConstant).value}`;
case ast.VariableRef: return `${(e as ast.VariableRef).variable.ref?.name}`;
default: throw new Error(`Unknown expression type: ${e.$type}`);
}
}
const assertRepr = async (input: string) => {
try {
const parse = await helper(input);
const elements = parse.parseResult.value.elements;
console.log(parse.parseResult);
return stringRepr(parse.parseResult.value.elements[elements.length - 1].expression);
} catch(error) {
return error;
}
}
});ResultOk ... so At this point, I'm out on a far enough ledge to see if I'm just doing something silly. |
Beta Was this translation helpful? Give feedback.
-
|
@msujew Disregard - missing Associativity Test Code (Final)describe('Expressions Parser', () => {
it('should have associative addition', async () => {
const input = `10 + 5 + 1 + 2`;
const expected = `(((10 + 5) + 1) + 2)`;
expect(await assertRepr(input)).toBe(expected);
});
function stringRepr(e: ast.Expression): string {
switch (e.$type) {
case ast.Plus: return `(${stringRepr((e as ast.Plus).left)} + ${stringRepr((e as ast.Plus).right)})`;
case ast.IntConstant: return `${(e as ast.IntConstant).value}`;
case ast.StringConstant: return `${(e as ast.StringConstant).value}`;
case ast.BoolConstant: return `${(e as ast.BoolConstant).value}`;
case ast.VariableRef: return `${(e as ast.VariableRef).variable.ref?.name}`;
default: throw new Error(`Unknown expression type: ${e.$type}`);
}
}
const assertRepr = async (input: string) => {
const parse = await helper('eval ' + input);
const elements = parse.parseResult.value.elements;
return stringRepr(parse.parseResult.value.elements[elements.length - 1].expression);
}
}); |
Beta Was this translation helpful? Give feedback.
Tag: @msujew
Disregard - I'll leave this here in case anyone else is curious. I'm assuming that since we don't have dynamic dispatch (Xtend) that means that we have to call
format()on all of the nodes of the AST and select which nodes to apply formatting to using the utilityisSomeType()function. Please feel free to clarify if I'm off the mark.