@reqlan/language 1.4.1 → 1.5.0

package/src/reqlan-definition-provider.ts

@@ -30,6 +30,7 @@ import {
     isFileSymbolReference,
     isFromImport,
     isImport,
+    isInvalidFromImport,
     isLocalReference,
     isQualifiedReference,
     type FileReference,
@@ -308,7 +309,7 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
 }
 
 function isImportPathTarget(node: unknown, targetCst: CstNode): node is Import {
-    if (!isImport(node)) {
+    if (!isImport(node) || isInvalidFromImport(node)) {
         return false;
     }
     if (isFromImport(node) || !node.alias) {

package/src/reqlan-file-link-resolver.ts

@@ -7,6 +7,7 @@ import type { Range } from 'vscode-languageserver';
 import { resolveFileUri } from './reqlan-comment-resolver.js';
 import type { EmbeddedFileReference } from './reqlan-embedded-file-references.js';
 import { findEmbeddedFileReferencesInText } from './reqlan-embedded-file-references.js';
+import { importPathOf } from './reqlan-import-bindings.js';
 import { findImportedDocument, resolveExistingImportUri } from './reqlan-imports.js';
 import type { PathResolveContext } from './reqlan-path-resolve.js';
 import { qualifiedReferenceImportPath } from './reqlan-references.js';
@@ -100,12 +101,16 @@ export function resolveImportPathLink(
     documents: LangiumDocuments,
     context?: PathResolveContext
 ): ResolvedFileLink | undefined {
+    const path = importPathOf(importDecl);
+    if (!path) {
+        return undefined;
+    }
     const document = AstUtils.getDocument(importDecl);
     const pathNode = GrammarUtils.findNodeForProperty(importDecl.$cstNode, 'path');
     if (!pathNode) {
         return undefined;
     }
-    const imported = findImportedDocument(importDecl.path, document, documents, context);
+    const imported = findImportedDocument(path, document, documents, context);
     const target = imported?.parseResult.value.$cstNode;
     if (!imported || !target) {
         return undefined;

package/src/reqlan-import-bindings.ts

@@ -1,10 +1,13 @@
 import type { AstNode } from 'langium';
 import {
     isFromImport,
+    isInvalidFromImport,
     isNamespaceImport,
     isQualifiedImport,
+    type FromImport,
     type FromImportSpecifier,
-    type Import
+    type Import,
+    type InvalidFromImport
 } from './generated/ast.js';
 
 export interface ImportBinding {
@@ -13,12 +16,31 @@ export interface ImportBinding {
     property: 'alias' | 'idea';
 }
 
+export type PathBearingImport = Exclude<Import, InvalidFromImport>;
+
 export function specifierBindingName(specifier: FromImportSpecifier): string | undefined {
     return specifier.alias ?? specifier.idea.$refText;
 }
 
+/** True when a from-import has the required `import <idea>` clause. */
+export function isWellFormedFromImport(importDecl: FromImport): boolean {
+    return importDecl.specifiers.length > 0;
+}
+
+export function isPathBearingImport(importDecl: Import): importDecl is PathBearingImport {
+    return !isInvalidFromImport(importDecl);
+}
+
+export function importPathOf(importDecl: Import): string | undefined {
+    return isPathBearingImport(importDecl) ? importDecl.path : undefined;
+}
+
 export function importBindings(importDecl: Import): ImportBinding[] {
     if (isFromImport(importDecl)) {
+        // Mistaken `from "path" as alias` (no idea specifiers) must not bind a name.
+        if (!isWellFormedFromImport(importDecl)) {
+            return [];
+        }
         return importDecl.specifiers.flatMap(specifier => {
             const name = specifierBindingName(specifier);
             if (!name) {
@@ -31,6 +53,9 @@ export function importBindings(importDecl: Import): ImportBinding[] {
             }];
         });
     }
+    if (isInvalidFromImport(importDecl)) {
+        return [];
+    }
     if (isQualifiedImport(importDecl)) {
         const name = importDecl.alias ?? importDecl.idea.$refText;
         if (!name) {

package/src/reqlan-namespace-import-links.ts

@@ -4,7 +4,7 @@
 import type { CstNode, FileSystemProvider, LangiumDocuments } from 'langium';
 import { AstUtils, GrammarUtils } from 'langium';
 import { isIdea, isModel, isOneLinerIdea, type Import, type LocalReference, type QualifiedReference } from './generated/ast.js';
-import { findNamespaceImportByAlias } from './reqlan-import-bindings.js';
+import { findNamespaceImportByAlias, importPathOf } from './reqlan-import-bindings.js';
 import { bindingNameSourceRange, resolveImportedFileLink, type ResolvedFileLink } from './reqlan-file-link-resolver.js';
 import type { PathResolveContext } from './reqlan-path-resolve.js';
 
@@ -62,15 +62,16 @@ export function resolveNamespaceImportReferenceLink(
     if (!importDecl || !isNamespaceImportBinding(importDecl, bindingName)) {
         return undefined;
     }
+    const path = importPathOf(importDecl);
     const pathNode = referencePathNode(reference, importDecl);
-    if (!pathNode) {
+    if (!path || !pathNode) {
         return undefined;
     }
     return resolveImportedFileLink(
         document,
         documents,
         fileSystem,
-        importDecl.path,
+        path,
         bindingNameSourceRange(pathNode, bindingName),
         context
     );

package/src/reqlan-path-resolve.ts

@@ -30,6 +30,7 @@ export interface RqHtmlExportConfig {
     includeFilePages?: boolean;
     includeCodeFilePages?: boolean;
     includeClusterPages?: boolean;
+    includeAttributePages?: boolean;
     includePrintPages?: boolean;
 }
 
@@ -253,6 +254,9 @@ function parseHtmlExportConfig(raw: unknown): RqHtmlExportConfig | undefined {
     if (typeof record.includeClusterPages === 'boolean') {
         config.includeClusterPages = record.includeClusterPages;
     }
+    if (typeof record.includeAttributePages === 'boolean') {
+        config.includeAttributePages = record.includeAttributePages;
+    }
     if (typeof record.includePrintPages === 'boolean') {
         config.includePrintPages = record.includePrintPages;
     }

package/src/reqlan-references.ts

@@ -12,6 +12,7 @@ import {
     type QualifiedReference,
     type ReferenceTarget
 } from './generated/ast.js';
+import { importPathOf } from './reqlan-import-bindings.js';
 import { unquoteReqlanString } from './reqlan-quoted-strings.js';
 
 export function referenceImport(target: ReferenceTarget): Reference<Import> | undefined {
@@ -40,10 +41,10 @@ export function referenceFilePath(target: ReferenceTarget): string | undefined {
 
 export function qualifiedReferenceImportPath(reference: QualifiedReference): string | undefined {
     if (reference.qualifier?.ref) {
-        return reference.qualifier.ref.path;
+        return importPathOf(reference.qualifier.ref);
     }
     if (reference.path?.ref) {
-        return reference.path.ref.path;
+        return importPathOf(reference.path.ref);
     }
     if (reference.path?.$refText) {
         return unquoteReqlanString(reference.path.$refText);

package/src/reqlan-scope.ts

@@ -8,6 +8,7 @@ import {
     isFromImportSpecifier,
     isIdea,
     isIdeaSet,
+    isInvalidFromImport,
     isLocalReference,
     isModel,
     isNamespaceImport,
@@ -20,7 +21,7 @@ import {
     type Model,
     type QualifiedReference
 } from './generated/ast.js';
-import { findFromImportSpecifierByBinding, specifierBindingName } from './reqlan-import-bindings.js';
+import { findFromImportSpecifierByBinding, importPathOf, specifierBindingName } from './reqlan-import-bindings.js';
 import { findImportedDocument } from './reqlan-imports.js';
 import type { ReqlanServices } from './reqlan-module.js';
 import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
@@ -202,9 +203,12 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
         if (!isModel(model)) {
             return new StreamScope(stream([]));
         }
-        const descriptions = model.imports.map(importDecl =>
-            this.descriptions.createDescription(importDecl, importDecl.path, document)
-        );
+        const descriptions = model.imports.flatMap(importDecl => {
+            const path = importPathOf(importDecl);
+            return path
+                ? [this.descriptions.createDescription(importDecl, path, document)]
+                : [];
+        });
         return new StreamScope(stream(descriptions));
     }
 
@@ -305,7 +309,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
 }
 
 function importAlias(entry: Import): string | undefined {
-    if (isFromImport(entry)) {
+    if (isFromImport(entry) || isInvalidFromImport(entry)) {
         return undefined;
     }
     return entry.alias;

package/src/reqlan-semantic-token-provider.ts

@@ -14,6 +14,7 @@ import {
     isIdea,
     isIdeaSet,
     isImport,
+    isInvalidFromImport,
     isLocalReference,
     isMarkdownLink,
     isQualifiedImport,
@@ -21,6 +22,7 @@ import {
     isOneLinerIdea,
     type Import
 } from './generated/ast.js';
+import { isWellFormedFromImport } from './reqlan-import-bindings.js';
 
 export class ReqlanSemanticTokenProvider extends AbstractSemanticTokenProvider {
 
@@ -84,8 +86,12 @@ export class ReqlanSemanticTokenProvider extends AbstractSemanticTokenProvider {
         }
         if (isImport(node)) {
             highlightImportKeywords(node, acceptor);
-            acceptor({ node, property: 'path', type: SemanticTokenTypes.string, modifier: SemanticTokenModifiers.declaration });
-            if (!isFromImport(node) && node.alias) {
+            if (!isInvalidFromImport(node)) {
+                acceptor({ node, property: 'path', type: SemanticTokenTypes.string, modifier: SemanticTokenModifiers.declaration });
+            }
+            if (isFromImport(node) && node.alias) {
+                acceptor({ node, property: 'alias', type: SemanticTokenTypes.namespace });
+            } else if (!isFromImport(node) && !isInvalidFromImport(node) && node.alias) {
                 acceptor({ node, property: 'alias', type: SemanticTokenTypes.namespace, modifier: SemanticTokenModifiers.declaration });
             }
         }
@@ -103,11 +109,23 @@ export class ReqlanSemanticTokenProvider extends AbstractSemanticTokenProvider {
 }
 
 function highlightImportKeywords(node: Import, acceptor: SemanticTokenAcceptor): void {
-    if (isFromImport(node)) {
+    if (isFromImport(node) || isInvalidFromImport(node)) {
         acceptor({ node, keyword: 'from', type: SemanticTokenTypes.keyword });
     }
+    if (isFromImport(node)) {
+        if (isWellFormedFromImport(node)) {
+            acceptor({ node, keyword: 'import', type: SemanticTokenTypes.keyword });
+        }
+        if (node.alias) {
+            acceptor({ node, keyword: 'as', type: SemanticTokenTypes.keyword });
+        }
+        return;
+    }
+    if (isInvalidFromImport(node)) {
+        return;
+    }
     acceptor({ node, keyword: 'import', type: SemanticTokenTypes.keyword });
-    if (!isFromImport(node) && node.alias) {
+    if (node.alias) {
         acceptor({ node, keyword: 'as', type: SemanticTokenTypes.keyword });
     }
 }

package/src/reqlan-validator.ts

@@ -2,7 +2,9 @@ import type { AstNode, ValidationAcceptor, ValidationChecks } from 'langium';
 import { AstUtils } from 'langium';
 import type { ReqlanAstType } from './generated/ast.js';
 import {
+    isFromImport,
     isIdea,
+    isInvalidFromImport,
     isOneLinerIdea,
     type Model
 } from './generated/ast.js';
@@ -10,7 +12,12 @@ import {
     collectFileLinks,
     fileLinkTargetIssueMessage
 } from './reqlan-file-link-resolver.js';
-import { importBindings, importedIdeaNames } from './reqlan-import-bindings.js';
+import {
+    importBindings,
+    importPathOf,
+    importedIdeaNames,
+    isWellFormedFromImport
+} from './reqlan-import-bindings.js';
 import { isResolvableImportPath } from './reqlan-imports.js';
 import type { ReqlanServices } from './reqlan-module.js';
 import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
@@ -19,6 +26,7 @@ import { unquoteReqlanString } from './reqlan-quoted-strings.js';
 /**
  * Registers validation hooks for the requirement graph AST.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
+ * rq:["../../../reqlan rq/language/imports.rq".import_error_recovery]
  */
 export function registerValidationChecks(services: ReqlanServices) {
     const registry = services.validation.ValidationRegistry;
@@ -32,6 +40,7 @@ export function registerValidationChecks(services: ReqlanServices) {
 /**
  * Custom validations for Reqlan documents.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
+ * rq:["../../../reqlan rq/language/imports.rq".import_error_recovery]
  */
 export class ReqlanValidator {
 
@@ -40,10 +49,42 @@ export class ReqlanValidator {
     checkModelDuplicates(model: Model, accept: ValidationAcceptor): void {
         this.checkDuplicateImportBindings(model, accept);
         this.checkDuplicateIdeaNames(model, accept);
+        this.checkImportSyntax(model, accept);
         this.checkImportTargets(model, accept);
         this.checkFileReferenceTargets(model, accept);
     }
 
+    /**
+     * Local diagnostics for recoverable but invalid import shapes.
+     * Keeps the rest of the file parseable — see import_error_recovery.
+     */
+    checkImportSyntax(model: Model, accept: ValidationAcceptor): void {
+        for (const importDecl of model.imports) {
+            if (isInvalidFromImport(importDecl)) {
+                accept('error', 'Invalid from-import: expected a quoted path, then `import <idea>`.', {
+                    node: importDecl
+                });
+                continue;
+            }
+            if (!isFromImport(importDecl) || isWellFormedFromImport(importDecl)) {
+                continue;
+            }
+            if (importDecl.alias) {
+                accept(
+                    'error',
+                    `Invalid syntax: use \`import "${unquoteReqlanString(importDecl.path)}" as ${importDecl.alias}\` for a namespace import, or \`from "${unquoteReqlanString(importDecl.path)}" import <idea>\`.`,
+                    { node: importDecl }
+                );
+                continue;
+            }
+            accept(
+                'error',
+                `Invalid from-import: expected \`from "${unquoteReqlanString(importDecl.path)}" import <idea>\`.`,
+                { node: importDecl }
+            );
+        }
+    }
+
     checkDuplicateImportBindings(model: Model, accept: ValidationAcceptor): void {
         const seen = new Map<string, ImportBindingSource>();
         for (const importDecl of model.imports) {
@@ -102,7 +143,14 @@ export class ReqlanValidator {
         const { shared } = this.services;
         const pathContext = pathResolveContextFromServices(this.services);
         for (const importDecl of model.imports) {
-            const path = unquoteReqlanString(importDecl.path);
+            if (isInvalidFromImport(importDecl)) {
+                continue;
+            }
+            if (isFromImport(importDecl) && !isWellFormedFromImport(importDecl)) {
+                continue;
+            }
+            const rawPath = importPathOf(importDecl);
+            const path = rawPath ? unquoteReqlanString(rawPath) : undefined;
             if (!path || isRemoteImportPath(path)) {
                 continue;
             }

package/src/reqlan-workspace-attribute-catalog.ts

@@ -3,7 +3,14 @@
  */
 import type { LangiumDocuments } from 'langium';
 import { AstUtils } from 'langium';
-import { isAttribute, isModel, isScalarValue, type Attribute } from './generated/ast.js';
+import {
+    isAttribute,
+    isBlockValue,
+    isListValue,
+    isModel,
+    isScalarValue,
+    type Attribute
+} from './generated/ast.js';
 import type { AttributeCatalog } from './reqlan-attribute-catalog.js';
 
 export function collectWorkspaceAttributeCatalog(documents: LangiumDocuments): AttributeCatalog {
@@ -41,22 +48,50 @@ function valuesForAttribute(attribute: Attribute): string[] {
         return [];
     }
     if (isScalarValue(attribute.value)) {
-        const text = attribute.value.parts
-            .map(part => typeof part === 'string' ? part : '')
-            .join('')
-            .trim();
+        const text = normalizeCatalogText(attribute.value.$cstNode?.text)
+            || inlineCatalogParts(attribute.value.parts);
         return text ? [text] : [];
     }
-    if (attribute.value.$type === 'ListValue') {
-        return attribute.value.items.flatMap(item => {
-            if (item.$type === 'OneLinerListItem') {
-                return item.body.content
-                    .map(part => typeof part === 'string' ? part : '')
-                    .join('')
-                    .trim();
-            }
-            return [];
-        }).filter(Boolean);
+    if (isListValue(attribute.value)) {
+        return attribute.value.items
+            .map(item => normalizeCatalogText(item.$cstNode?.text))
+            .filter(Boolean);
+    }
+    if (isBlockValue(attribute.value)) {
+        const raw = attribute.value.$cstNode?.text ?? '';
+        const inner = raw.replace(/^\{\s*/, '').replace(/\s*\}$/, '').trim();
+        return inner ? [inner.replace(/\s+/g, ' ')] : [];
     }
     return [];
 }
+
+function normalizeCatalogText(text: string | undefined): string {
+    return text?.replace(/\s+/g, ' ').trim() ?? '';
+}
+
+function inlineCatalogParts(parts: ReadonlyArray<unknown>): string {
+    return parts
+        .map(part => {
+            if (typeof part === 'string') {
+                return part;
+            }
+            if (!part || typeof part !== 'object') {
+                return '';
+            }
+            const node = part as {
+                text?: string;
+                inlineCode?: string;
+                $cstNode?: { text?: string };
+            };
+            if (typeof node.text === 'string' && node.text.length > 0) {
+                return node.text;
+            }
+            if (typeof node.inlineCode === 'string' && node.inlineCode.length > 0) {
+                return node.inlineCode;
+            }
+            return node.$cstNode?.text ?? '';
+        })
+        .join('')
+        .replace(/\s+/g, ' ')
+        .trim();
+}

package/src/reqlan.langium

@@ -200,13 +200,19 @@ LocalReference:
 
 // ---------------------------------------------------------------------------
 // import_from, import_namespace, import_qualified — see imports.rq
+// InvalidFromImport recovers unquoted/malformed `from` lines so later ideas still parse.
+// FromImport allows a mistaken `from "path" as alias` shape for a local diagnostic
+// (valid form still requires `import` + idea specifiers).
 // ---------------------------------------------------------------------------
 
 Import:
-    FromImport | NamespaceImport | QualifiedImport;
+    FromImport | NamespaceImport | QualifiedImport | InvalidFromImport;
 
 FromImport:
-    'from' path=STRING 'import' specifiers+=FromImportSpecifier (',' specifiers+=FromImportSpecifier)*;
+    'from' path=STRING (
+        'import' specifiers+=FromImportSpecifier (',' specifiers+=FromImportSpecifier)*
+      | 'as' alias=ID
+    )?;
 
 FromImportSpecifier:
     idea=[IdeaDeclaration:ID] ('as' alias=ID)?;
@@ -217,6 +223,16 @@ NamespaceImport:
 QualifiedImport:
     'import' path=STRING '.' ideaset=ID '.' idea=[IdeaDeclaration:ID] ('as' alias=ID)?;
 
+// `from` not followed by a quoted path — consume the rest of the line.
+InvalidFromImport:
+    'from' head=InvalidImportHeadToken tokens+=InvalidImportToken*;
+
+InvalidImportHeadToken returns string:
+    ID | WORD | NUMBER | OTHER | PlainPunctuation | '(' | ')' | '|' | 'as' | 'import' | 'from' | '`' | '[' | ']';
+
+InvalidImportToken returns string:
+    ID | STRING | WORD | NUMBER | OTHER | PlainPunctuation | '(' | ')' | '|' | 'as' | 'import' | 'from' | '`' | '[' | ']';
+
 // ---------------------------------------------------------------------------
 // comments, string_literals
 // ---------------------------------------------------------------------------