@prisma-next/psl-parser 0.14.0-dev.6 → 0.14.0-dev.61

package/src/exports/syntax.ts

@@ -7,7 +7,13 @@ export {
   FieldAttributeAst,
   ModelAttributeAst,
 } from '../syntax/ast/attributes';
-export type { NamespaceMemberAst } from '../syntax/ast/declarations';
+export type {
+  AttributeAst,
+  BlockMemberAst,
+  DeclarationAst,
+  GenericBlockMemberAst,
+  NamespaceMemberAst,
+} from '../syntax/ast/declarations';
 export {
   CompositeTypeDeclarationAst,
   DocumentAst,
@@ -35,12 +41,26 @@ export {
 export { IdentifierAst } from '../syntax/ast/identifier';
 export { QualifiedNameAst } from '../syntax/ast/qualified-name';
 export { TypeAnnotationAst } from '../syntax/ast/type-annotation';
-export type { AstNode } from '../syntax/ast-helpers';
-export { filterChildren, findChildToken, findFirstChild, printSyntax } from '../syntax/ast-helpers';
+export type { AstNode, BracedBlock } from '../syntax/ast-helpers';
+export {
+  any,
+  filterChildren,
+  findChildToken,
+  findFirstChild,
+  printSyntax,
+} from '../syntax/ast-helpers';
 export type { GreenElement, GreenNode, GreenToken } from '../syntax/green';
 export { greenNode, greenToken } from '../syntax/green';
 export { GreenNodeBuilder } from '../syntax/green-builder';
+// Navigation helpers
+export type { Direction } from '../syntax/navigation';
+export {
+  isTrivia,
+  isTriviaKind,
+  nonTriviaSibling,
+  skipTriviaToken,
+} from '../syntax/navigation';
 // Red layer
-export type { SyntaxElement, SyntaxToken } from '../syntax/red';
-export { createSyntaxTree, SyntaxNode } from '../syntax/red';
+export type { SyntaxElement } from '../syntax/red';
+export { createSyntaxTree, SyntaxNode, SyntaxToken, TokenAtOffset } from '../syntax/red';
 export type { SyntaxKind } from '../syntax/syntax-kind';

package/src/interpret.ts

@@ -0,0 +1,40 @@
+import type {
+  ContractSourceContext,
+  ContractSourceDiagnostic,
+  ContractSourceProvider,
+  PslContractSourceProvider,
+} from '@prisma-next/config/config-types';
+import type { SourceFile } from './source-file';
+import type { SymbolTable } from './symbol-table';
+import type { DocumentAst } from './syntax/ast/declarations';
+
+/**
+ * Lets editor tooling that already parses incrementally (e.g. the language
+ * server) hand cached artifacts to the interpreter instead of forcing a
+ * disk re-parse.
+ */
+export interface PslInterpretInput {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+  readonly symbolTable: SymbolTable;
+  readonly sourceId: string;
+}
+
+/**
+ * Declared here — the authoring layer that owns `DocumentAst` / `SourceFile` /
+ * `SymbolTable` — because `@prisma-next/config` (core) cannot name authoring
+ * types.
+ */
+export interface PslInterpretCapable extends PslContractSourceProvider {
+  interpret(
+    input: PslInterpretInput,
+    context: ContractSourceContext,
+  ): readonly ContractSourceDiagnostic[];
+}
+
+/** The single seam that narrows a contract source to the interpret capability. */
+export function hasPslInterpreter(source: ContractSourceProvider): source is PslInterpretCapable {
+  return (
+    source.sourceFormat === 'psl' && 'interpret' in source && typeof source.interpret === 'function'
+  );
+}

package/src/parse.ts

@@ -399,14 +399,24 @@ function parseParenArgs(cursor: Cursor): void {
   }
 }
 
-export function parseAttributeArg(cursor: Cursor): GreenNode {
+export function parseAttributeArg(cursor: Cursor): void {
+  const kind = cursor.peekKind();
+  if (
+    kind !== 'Ident' &&
+    kind !== 'StringLiteral' &&
+    kind !== 'NumberLiteral' &&
+    kind !== 'LBracket' &&
+    kind !== 'LBrace'
+  ) {
+    return;
+  }
   cursor.startNode('AttributeArg');
   if (cursor.peekKind() === 'Ident' && cursor.peekKind(1) === 'Colon') {
     parseIdentifier(cursor);
     cursor.bump();
   }
   parseArgValue(cursor);
-  return cursor.finishNode();
+  cursor.finishNode();
 }
 
 function parseArgValue(cursor: Cursor): void {
@@ -435,8 +445,16 @@ export function parseAttribute(cursor: Cursor): GreenNode {
   return cursor.finishNode();
 }
 
-/** A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g. `pgvector.Vector(1536)[]?`. */
-export function parseTypeAnnotation(cursor: Cursor): GreenNode {
+/**
+ * A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g.
+ * `pgvector.Vector(1536)[]?`. When the field has no type, no node is emitted —
+ * a missing type is the absence of a `TypeAnnotation`, not a zero-width one.
+ */
+export function parseTypeAnnotation(cursor: Cursor): void {
+  const kind = cursor.peekKind();
+  if (kind !== 'Ident' && kind !== 'LBracket' && kind !== 'Question') {
+    return;
+  }
   cursor.startNode('TypeAnnotation');
   if (cursor.peekKind() === 'Ident') {
     parseQualifiedName(cursor);
@@ -453,7 +471,7 @@ export function parseTypeAnnotation(cursor: Cursor): GreenNode {
   if (cursor.peekKind() === 'Question') {
     cursor.bump();
   }
-  return cursor.finishNode();
+  cursor.finishNode();
 }
 
 type MemberParser = (cursor: Cursor) => void;

package/src/resolve.ts

@@ -15,6 +15,7 @@ export interface ResolvedAttributeArg {
   readonly kind: 'positional' | 'named';
   readonly name?: string;
   readonly value: string;
+  readonly expression?: ExpressionAst;
   readonly span: PslSpan;
 }
 
@@ -69,10 +70,12 @@ function readResolvedArgList(
   const args: ResolvedAttributeArg[] = [];
   for (const arg of argList.args()) {
     const name = arg.name()?.name();
+    const expression = arg.value();
     args.push({
       kind: name !== undefined ? 'named' : 'positional',
       ...(name !== undefined ? { name } : {}),
-      value: renderExpression(arg.value()),
+      value: renderExpression(expression),
+      ...(expression !== undefined ? { expression } : {}),
       span: nodePslSpan(arg.syntax, sourceFile),
     });
   }

package/src/source-file.ts

@@ -1,3 +1,4 @@
+const CARRIAGE_RETURN = 13;
 const LINE_FEED = 10;
 
 export interface Position {
@@ -41,6 +42,30 @@ export class SourceFile {
     return this.#lineStarts;
   }
 
+  lineStartOffset(line: number): number {
+    if (line <= 0) {
+      return 0;
+    }
+    return this.#lineStarts[line] ?? this.#text.length;
+  }
+
+  lineEndOffset(line: number): number {
+    if (line < 0) {
+      return 0;
+    }
+
+    const nextLineStart = this.#lineStarts[line + 1];
+    if (nextLineStart === undefined) {
+      return this.#text.length;
+    }
+
+    const lineFeedOffset = nextLineStart - 1;
+    const carriageReturnOffset = lineFeedOffset - 1;
+    return this.#text.charCodeAt(carriageReturnOffset) === CARRIAGE_RETURN
+      ? carriageReturnOffset
+      : lineFeedOffset;
+  }
+
   positionAt(offset: number): Position {
     const clamped = clamp(offset, 0, this.#text.length);
     const line = this.#lineIndexAt(clamped);

package/src/syntax/ast/attributes.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
-import type { SyntaxNode } from '../red';
+import type { SyntaxNode, SyntaxToken } from '../red';
 import { AttributeArgAst } from './expressions';
 import { QualifiedNameAst } from './qualified-name';
 
@@ -12,11 +11,11 @@ export class AttributeArgListAst implements AstNode {
     this.syntax = syntax;
   }
 
-  lparen(): Token | undefined {
+  lparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LParen');
   }
 
-  rparen(): Token | undefined {
+  rparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RParen');
   }
 
@@ -36,7 +35,7 @@ export class FieldAttributeAst implements AstNode {
     this.syntax = syntax;
   }
 
-  at(): Token | undefined {
+  at(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'At');
   }
 
@@ -60,7 +59,7 @@ export class ModelAttributeAst implements AstNode {
     this.syntax = syntax;
   }
 
-  doubleAt(): Token | undefined {
+  doubleAt(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'DoubleAt');
   }
 

package/src/syntax/ast/declarations.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
-import type { AstNode } from '../ast-helpers';
+import type { AstNode, BracedBlock } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
-import { SyntaxNode } from '../red';
+import { SyntaxNode, type SyntaxToken } from '../red';
 import { FieldAttributeAst, ModelAttributeAst } from './attributes';
 import type { ExpressionAst } from './expressions';
 import { castExpression } from './expressions';
@@ -18,6 +17,11 @@ export type NamespaceMemberAst =
   | CompositeTypeDeclarationAst
   | GenericBlockDeclarationAst;
 
+export type DeclarationAst = NamespaceMemberAst | TypesBlockAst | NamespaceDeclarationAst;
+export type AttributeAst = FieldAttributeAst | ModelAttributeAst;
+export type BlockMemberAst = FieldDeclarationAst | ModelAttributeAst;
+export type GenericBlockMemberAst = KeyValuePairAst | ModelAttributeAst;
+
 function castNamespaceMember(node: SyntaxNode): NamespaceMemberAst | undefined {
   return (
     ModelDeclarationAst.cast(node) ??
@@ -33,7 +37,7 @@ export class DocumentAst implements AstNode {
     this.syntax = syntax;
   }
 
-  *declarations(): Iterable<NamespaceMemberAst | TypesBlockAst | NamespaceDeclarationAst> {
+  *declarations(): Iterable<DeclarationAst> {
     yield* filterChildren(
       this.syntax,
       (node) =>
@@ -46,14 +50,14 @@ export class DocumentAst implements AstNode {
   }
 }
 
-export class ModelDeclarationAst implements AstNode {
+export class ModelDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
     this.syntax = syntax;
   }
 
-  keyword(): Token | undefined {
+  keyword(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
@@ -61,11 +65,11 @@ export class ModelDeclarationAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -77,19 +81,26 @@ export class ModelDeclarationAst implements AstNode {
     yield* filterChildren(this.syntax, ModelAttributeAst.cast);
   }
 
+  *members(): Iterable<BlockMemberAst> {
+    yield* filterChildren(
+      this.syntax,
+      (node) => FieldDeclarationAst.cast(node) ?? ModelAttributeAst.cast(node),
+    );
+  }
+
   static cast(node: SyntaxNode): ModelDeclarationAst | undefined {
     return node.kind === 'ModelDeclaration' ? new ModelDeclarationAst(node) : undefined;
   }
 }
 
-export class CompositeTypeDeclarationAst implements AstNode {
+export class CompositeTypeDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
     this.syntax = syntax;
   }
 
-  keyword(): Token | undefined {
+  keyword(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
@@ -97,11 +108,11 @@ export class CompositeTypeDeclarationAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -113,6 +124,13 @@ export class CompositeTypeDeclarationAst implements AstNode {
     yield* filterChildren(this.syntax, ModelAttributeAst.cast);
   }
 
+  *members(): Iterable<BlockMemberAst> {
+    yield* filterChildren(
+      this.syntax,
+      (node) => FieldDeclarationAst.cast(node) ?? ModelAttributeAst.cast(node),
+    );
+  }
+
   static cast(node: SyntaxNode): CompositeTypeDeclarationAst | undefined {
     return node.kind === 'CompositeTypeDeclaration'
       ? new CompositeTypeDeclarationAst(node)
@@ -120,14 +138,14 @@ export class CompositeTypeDeclarationAst implements AstNode {
   }
 }
 
-export class NamespaceDeclarationAst implements AstNode {
+export class NamespaceDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
     this.syntax = syntax;
   }
 
-  keyword(): Token | undefined {
+  keyword(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
@@ -135,11 +153,11 @@ export class NamespaceDeclarationAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -152,22 +170,22 @@ export class NamespaceDeclarationAst implements AstNode {
   }
 }
 
-export class TypesBlockAst implements AstNode {
+export class TypesBlockAst implements BracedBlock {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
     this.syntax = syntax;
   }
 
-  keyword(): Token | undefined {
+  keyword(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -180,14 +198,14 @@ export class TypesBlockAst implements AstNode {
   }
 }
 
-export class GenericBlockDeclarationAst implements AstNode {
+export class GenericBlockDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
     this.syntax = syntax;
   }
 
-  keyword(): Token | undefined {
+  keyword(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
@@ -195,11 +213,11 @@ export class GenericBlockDeclarationAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -211,6 +229,13 @@ export class GenericBlockDeclarationAst implements AstNode {
     yield* filterChildren(this.syntax, ModelAttributeAst.cast);
   }
 
+  *members(): Iterable<GenericBlockMemberAst> {
+    yield* filterChildren(
+      this.syntax,
+      (node) => KeyValuePairAst.cast(node) ?? ModelAttributeAst.cast(node),
+    );
+  }
+
   static cast(node: SyntaxNode): GenericBlockDeclarationAst | undefined {
     return node.kind === 'GenericBlockDeclaration'
       ? new GenericBlockDeclarationAst(node)
@@ -229,7 +254,7 @@ export class KeyValuePairAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  equals(): Token | undefined {
+  equals(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Equals');
   }
 
@@ -288,7 +313,7 @@ export class NamedTypeDeclarationAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  equals(): Token | undefined {
+  equals(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Equals');
   }
 

package/src/syntax/ast/expressions.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
-import { SyntaxNode } from '../red';
+import { SyntaxNode, type SyntaxToken } from '../red';
 import { IdentifierAst } from './identifier';
 import { QualifiedNameAst } from './qualified-name';
 
@@ -32,11 +31,11 @@ export class FunctionCallAst implements AstNode {
     return segments;
   }
 
-  lparen(): Token | undefined {
+  lparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LParen');
   }
 
-  rparen(): Token | undefined {
+  rparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RParen');
   }
 
@@ -56,11 +55,11 @@ export class ArrayLiteralAst implements AstNode {
     this.syntax = syntax;
   }
 
-  lbracket(): Token | undefined {
+  lbracket(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBracket');
   }
 
-  rbracket(): Token | undefined {
+  rbracket(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBracket');
   }
 
@@ -156,7 +155,7 @@ export class StringLiteralExprAst implements AstNode {
     this.syntax = syntax;
   }
 
-  token(): Token | undefined {
+  token(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'StringLiteral');
   }
 
@@ -178,7 +177,7 @@ export class NumberLiteralExprAst implements AstNode {
     this.syntax = syntax;
   }
 
-  token(): Token | undefined {
+  token(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'NumberLiteral');
   }
 
@@ -200,7 +199,7 @@ export class BooleanLiteralExprAst implements AstNode {
     this.syntax = syntax;
   }
 
-  token(): Token | undefined {
+  token(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 
@@ -224,11 +223,11 @@ export class ObjectLiteralExprAst implements AstNode {
     this.syntax = syntax;
   }
 
-  lbrace(): Token | undefined {
+  lbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LBrace');
   }
 
-  rbrace(): Token | undefined {
+  rbrace(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RBrace');
   }
 
@@ -279,7 +278,7 @@ export class ObjectFieldAst implements AstNode {
     return undefined;
   }
 
-  colon(): Token | undefined {
+  colon(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Colon');
   }
 
@@ -339,7 +338,7 @@ export class AttributeArgAst implements AstNode {
     return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
-  colon(): Token | undefined {
+  colon(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Colon');
   }
 

package/src/syntax/ast/identifier.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
 import { findChildToken } from '../ast-helpers';
-import type { SyntaxNode } from '../red';
+import type { SyntaxNode, SyntaxToken } from '../red';
 
 export class IdentifierAst implements AstNode {
   readonly syntax: SyntaxNode;
@@ -10,7 +9,7 @@ export class IdentifierAst implements AstNode {
     this.syntax = syntax;
   }
 
-  token(): Token | undefined {
+  token(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Ident');
   }
 

package/src/syntax/ast/qualified-name.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
-import { SyntaxNode } from '../red';
+import { SyntaxNode, type SyntaxToken } from '../red';
 import { IdentifierAst } from './identifier';
 
 /** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
@@ -12,22 +11,20 @@ export class QualifiedNameAst implements AstNode {
     this.syntax = syntax;
   }
 
-  #lastSegment(): IdentifierAst | undefined {
-    let last: IdentifierAst | undefined;
+  #segmentBefore(boundary: number): IdentifierAst | undefined {
+    let found: IdentifierAst | undefined;
     for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
-      last = segment;
+      if (segment.syntax.offset >= boundary) break;
+      found = segment;
     }
-    return last;
+    return found;
   }
 
-  #penultimateSegment(): IdentifierAst | undefined {
-    let last: IdentifierAst | undefined;
-    let penultimate: IdentifierAst | undefined;
+  #segmentAfter(boundary: number): IdentifierAst | undefined {
     for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
-      penultimate = last;
-      last = segment;
+      if (segment.syntax.offset > boundary) return segment;
     }
-    return penultimate;
+    return undefined;
   }
 
   #separatorCount(kind: 'Dot' | 'Colon'): number {
@@ -38,26 +35,32 @@ export class QualifiedNameAst implements AstNode {
     return count;
   }
 
-  colon(): Token | undefined {
+  colon(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Colon');
   }
 
-  dot(): Token | undefined {
+  dot(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'Dot');
   }
 
   space(): IdentifierAst | undefined {
-    if (!this.colon()) return undefined;
-    return findFirstChild(this.syntax, IdentifierAst.cast);
+    const colon = this.colon();
+    if (!colon) return undefined;
+    return this.#segmentBefore(colon.offset);
   }
 
   namespace(): IdentifierAst | undefined {
-    if (!this.dot()) return undefined;
-    return this.#penultimateSegment();
+    const dot = this.dot();
+    if (!dot) return undefined;
+    return this.#segmentBefore(dot.offset);
   }
 
   identifier(): IdentifierAst | undefined {
-    return this.#lastSegment();
+    const dot = this.dot();
+    if (dot) return this.#segmentAfter(dot.offset);
+    const colon = this.colon();
+    if (colon) return this.#segmentAfter(colon.offset);
+    return findFirstChild(this.syntax, IdentifierAst.cast);
   }
 
   /**
@@ -73,6 +76,12 @@ export class QualifiedNameAst implements AstNode {
     return segments;
   }
 
+  /** True iff this is a single unqualified identifier whose text equals `name`. */
+  isSimpleName(name: string): boolean {
+    if (this.dot() !== undefined || this.colon() !== undefined) return false;
+    return this.identifier()?.token()?.text === name;
+  }
+
   /**
    * Flags a malformed name with more qualifier segments than allowed (a second
    * `:`-space or a second `.`-namespace).