langium generate: fixed a hidden bug in 'node-processor.ts' of Langiu…

…m's 'generate' facility

* added some test cases
* extended 'Vitest: Run Selected File' launch config
* brought config of the Vitest VSCode extension closer to the Vitest setup in 'vite.config.mts'

.vscode/launch.json

@@ -171,6 +171,11 @@
             "args": ["run", "${relativeFile}"],
             "smartStep": true,
             "console": "integratedTerminal",
+            "sourceMaps": true,
+            "outFiles": [
+                "${workspaceFolder}/packages/vscode-uri/lib/**/*.js",
+                "${workspaceFolder}/packages/langium/lib/**/*.js"
+            ]
         }
     ]
 }

.vscode/settings.json

@@ -11,7 +11,7 @@
         "javascript",
         "typescript"
     ],
-    "vitest.enable": true,
+    "vitest.configSearchPatternExclude": "{**/node_modules/**,**/dist/**,**/generated/**,**/templates/**,**/examples/hello*/**,**/.*/**,**/*.d.ts}",
     "[json]": {
         "editor.defaultFormatter": "vscode.json-language-features"
     },

packages/langium/src/generate/node-processor.ts

@@ -94,11 +94,12 @@ class Context {
         this.length -= this.lines[this.currentLineNumber].join('').length;
         this.lines[this.currentLineNumber] = [];
         this.pendingIndent = true;
+        this.recentNonImmediateIndents.length = 0;
     }
 
     addNewLine() {
-        this.pendingIndent = true;
         this.lines.push([]);
+        this.pendingIndent = true;
         this.recentNonImmediateIndents.length = 0;
     }
 
@@ -228,20 +229,20 @@ function hasContent(node: GeneratorNode | string, ctx: Context): boolean {
 
 function processStringNode(node: string, context: Context) {
     if (node) {
-        if (context.pendingIndent) {
-            handlePendingIndent(context, false);
-        }
+        handlePendingIndent(context, false);
         context.append(node);
     }
 }
 
 function handlePendingIndent(ctx: Context, endOfLine: boolean) {
-    let indent = '';
-    for (const indentNode of ctx.relevantIndents.filter(e => e.indentEmptyLines || !endOfLine)) {
-        indent += indentNode.indentation ?? ctx.defaultIndentation;
+    if (ctx.pendingIndent) {
+        let indent = '';
+        for (const indentNode of ctx.relevantIndents.filter(e => e.indentEmptyLines || !endOfLine)) {
+            indent += indentNode.indentation ?? ctx.defaultIndentation;
+        }
+        ctx.append(indent, true);
+        ctx.pendingIndent = false;
     }
-    ctx.append(indent, true);
-    ctx.pendingIndent = false;
 }
 
 function processCompositeNode(node: CompositeGeneratorNode, context: Context) {
@@ -288,9 +289,7 @@ function processNewLineNode(node: NewLineNode, context: Context) {
     if (node.ifNotEmpty && !hasNonWhitespace(context.currentLineContent)) {
         context.resetCurrentLine();
     } else {
-        if (context.pendingIndent) {
-            handlePendingIndent(context, true);
-        }
+        handlePendingIndent(context, true);
         context.append(node.lineDelimiter);
         context.addNewLine();
     }

packages/langium/test/generate/node.test.ts

@@ -172,6 +172,22 @@ describe('indentation', () => {
         expect(process(comp, '\t')).toBe(`No indent${EOL}\tIndent {${EOL}\t}${EOL}`);
     });
 
+    test('should indent nested template starting with a new line with \'ifNotEmpty\', with \'indentImmediately: false\'', () => {
+        const comp = new CompositeGeneratorNode();
+        comp.append('No indent', NL);
+        comp.indent({
+            indentImmediately: false,
+            indentedChildren: [
+                '\t',
+                NLEmpty,
+                'Indented',
+                NL,
+                'Indented',
+                NL
+            ]
+        });
+        expect(process(comp, '\t')).toBe(`No indent${EOL}\tIndented${EOL}\tIndented${EOL}`);
+    });
 });
 
 describe('composite', () => {

packages/langium/test/generate/template-node.test.ts

@@ -832,9 +832,47 @@ describe('Multiple nested substitution templates', () => {
                         generated text!
         `);
     });
+
+    test('Nested substitution of with indented nested template starting with an _undefined_ line', () => {
+        expect(
+            toString(n`
+                begin:
+                  ${n`
+                    ${undefined}
+                    ${nestedNode}
+                  `}
+            `)
+        ).toBe(
+            s`
+                begin:
+                  More
+                  generated text!
+            `
+        );
+    });
+
+    test('Nested substitution of with indented nested template starting with an _empty string_ line', () => {
+        expect(
+            toString(n`
+                begin:
+                  ${n`
+                    ${''}
+                    ${nestedNode}
+                  `}
+            `)
+        ).toBe(
+            s`
+                begin:
+                  ${/* 's' automatically trims the empty lines completely, so insert */'<DUMMY>'}
+                  More
+                  generated text!
+            `.replace('<DUMMY>', '')
+        );
+    });
+
 });
 
-describe('Embedded forEach loops', () => {
+describe('Joining lists', () => {
     test('ForEach loop with empty iterable', () => {
         const node = n`
             Data:
@@ -1083,6 +1121,18 @@ describe('Embedded forEach loops', () => {
               b
         `);
     });
+
+    test('Nested ForEach loop with empty iterable followed by an indented line', () => {
+        const node = n`
+            ${joinToNode([], { appendNewLineIfNotEmpty: true})}
+            a
+        `;
+        const text = toString(node);
+        expect(text).toBe(s`
+            a
+        `);
+    });
+
 });
 
 describe('Appending templates to existing nodes', () => {