@prisma/orm-framework 8.0.0-rc.14-dev.18 → 8.0.0-rc.14-dev.20

package/dist/psl-parser.mjs

@@ -4,9 +4,9 @@ import { a as or, i as okVoid, n as notOk, r as ok, t as and } from "./result-8O
 import { b as isAuthoringModelAttributeDescriptor, x as isAuthoringPslBlockDescriptor } from "./temporal-presets-DzBBD4St-BaL1QaZ7.mjs";
 import { a as flatPslModels, c as namespacePslExtensionBlocks } from "./psl-ast-CyvE6CR-.mjs";
 import { n as isPslIdentifier } from "./tokenizer-BMz7z2KR-J0yZ4im3.mjs";
-import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, y as ObjectLiteralExprAst } from "./declarations-C0VwsVFX-BcP1Nyv4.mjs";
-import { a as mapPslDiagnostics, c as readResolvedAttributes, i as keywordPslSpan, l as readResolvedConstructorCall, n as diagnosticFromSpan, o as nodePslSpan, r as diagnosticSource, s as readResolvedAttribute, t as createPslDiagnosticCollector } from "./resolve-GE34dgM6-D33m6YEw.mjs";
-//#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-0DYRY2eQ.mjs
+import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, b as PathExprAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, y as ObjectLiteralExprAst } from "./declarations-DDT0hm5r-BAMLVwKx.mjs";
+import { a as mapPslDiagnostics, c as readResolvedAttributes, i as keywordPslSpan, l as readResolvedConstructorCall, n as diagnosticFromSpan, o as nodePslSpan, r as diagnosticSource, s as readResolvedAttribute, t as createPslDiagnosticCollector } from "./resolve-C8PUf8zv-QAvnPhCt.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-DDQTCCCB.mjs
 function* modelAttributeDescriptors(namespace) {
 	for (const value of Object.values(namespace)) {
 		if (isAuthoringModelAttributeDescriptor(value)) {
@@ -37,6 +37,57 @@ function resolveDescribeUnresolvedType(pslDiagnostics) {
 	if (pslDiagnostics?.describeUnresolvedType === void 0) return;
 	return blindCast(pslDiagnostics.describeUnresolvedType);
 }
+function writtenEntityReference(node) {
+	const name = IdentifierAst.cast(node)?.name();
+	if (name !== void 0) return {
+		namespace: void 0,
+		name
+	};
+	const path = PathExprAst.cast(node)?.path();
+	if (path === void 0 || path.length !== 2) return void 0;
+	const [namespace, member] = path;
+	return namespace === void 0 || member === void 0 ? void 0 : {
+		namespace,
+		name: member
+	};
+}
+function describeWrittenEntityReference(reference) {
+	return reference.namespace === void 0 ? reference.name : `${reference.namespace}.${reference.name}`;
+}
+const references = /* @__PURE__ */ new WeakMap();
+function entityReference(resolution) {
+	switch (resolution.kind) {
+		case "model":
+		case "compositeType":
+		case "namedType":
+		case "block": return interned(resolution.symbol, resolution.namespace);
+		default: return;
+	}
+}
+function interned(declaration, namespace) {
+	const existing = references.get(declaration);
+	if (existing !== void 0) return existing;
+	const reference = {
+		declaration,
+		namespace
+	};
+	references.set(declaration, reference);
+	return reference;
+}
+function matchesSelector(reference, expected) {
+	const declaration = reference.declaration;
+	if (declaration.kind !== expected.kind) return false;
+	return expected.kind !== "block" || declaration.kind === "block" && declaration.keyword === expected.keyword;
+}
+function describeResolution(resolution) {
+	switch (resolution.kind) {
+		case "block": return resolution.symbol.keyword;
+		case "contributedType": return "scalar type";
+		case "crossSpace": return "cross-space reference";
+		case "unresolved": return "unresolved name";
+		default: return resolution.kind;
+	}
+}
 function blockSpecFactoryOf(descriptor) {
 	return blindCast(descriptor.spec);
 }
@@ -293,11 +344,22 @@ function walkEntities(symbolTable, stack, binder, visit) {
 	for (const entity of Object.values(topLevel.compositeTypes)) visit(entity);
 	for (const namespace of Object.values(topLevel.namespaces)) {
 		stack.push(binder.scopeAt(namespace.declarations[0].node.syntax));
-		for (const entity of Object.values(namespace.models)) visit(entity);
-		for (const entity of Object.values(namespace.compositeTypes)) visit(entity);
+		for (const entity of Object.values(namespace.models)) visit(entity, namespace);
+		for (const entity of Object.values(namespace.compositeTypes)) visit(entity, namespace);
 		stack.pop();
 	}
 }
+function declarationResolution(entity, namespace) {
+	return entity.kind === "model" ? {
+		kind: "model",
+		symbol: entity,
+		...namespace === void 0 ? {} : { namespace }
+	} : {
+		kind: "compositeType",
+		symbol: entity,
+		...namespace === void 0 ? {} : { namespace }
+	};
+}
 function createBinder(input) {
 	const { symbolTable, sources, context } = input;
 	const contributions = context.authoringContributions;
@@ -331,24 +393,51 @@ function bind(options) {
 	const baseScope = namedTypeBaseScope(symbolTable.topLevel, contributed);
 	for (const symbol of Object.values(symbolTable.topLevel.namedTypes)) {
 		declarations.set(symbol.node.syntax, symbol);
+		const declaredName = symbol.node.name()?.syntax;
+		if (declaredName !== void 0) references.set(declaredName, {
+			kind: "namedType",
+			symbol
+		});
 		const name = symbol.node.typeAnnotation()?.name();
 		const outcome = resolveTypeReference(name, baseScope);
 		if (name === void 0 || outcome === void 0) continue;
 		references.set(name.syntax, outcome.resolution);
 	}
-	for (const symbol of Object.values(symbolTable.topLevel.blocks)) declarations.set(symbol.node.syntax, symbol);
+	for (const symbol of Object.values(symbolTable.topLevel.blocks)) {
+		declarations.set(symbol.node.syntax, symbol);
+		const declaredName = symbol.node.name()?.syntax;
+		if (declaredName !== void 0) references.set(declaredName, {
+			kind: "block",
+			symbol
+		});
+	}
 	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
 		const scope = namespaceScope(namespace, document);
 		for (const declaration of namespace.declarations) {
 			declarations.set(declaration.node.syntax, namespace);
 			scopes.set(declaration.node.syntax, scope);
 		}
-		for (const symbol of Object.values(namespace.blocks)) declarations.set(symbol.node.syntax, symbol);
+		for (const symbol of Object.values(namespace.blocks)) {
+			declarations.set(symbol.node.syntax, symbol);
+			const declaredName = symbol.node.name()?.syntax;
+			if (declaredName !== void 0) references.set(declaredName, {
+				kind: "block",
+				symbol,
+				namespace
+			});
+		}
 	}
-	walkEntities(symbolTable, stack, binder, (entity) => {
+	walkEntities(symbolTable, stack, binder, (entity, namespace) => {
 		declarations.set(entity.node.syntax, entity);
+		const declaredName = entity.node.name()?.syntax;
+		if (declaredName !== void 0) references.set(declaredName, declarationResolution(entity, namespace));
 		for (const field of Object.values(entity.fields)) {
 			declarations.set(field.node.syntax, field);
+			const fieldName = field.node.name()?.syntax;
+			if (fieldName !== void 0) references.set(fieldName, {
+				kind: "field",
+				symbol: field
+			});
 			const node = typeReferenceNode(field);
 			if (node === void 0) continue;
 			const outcome = resolveTypeReference(field.node.typeAnnotation()?.name(), stack.current(), (written) => describeUnresolvedType?.({
@@ -431,10 +520,7 @@ function bind(options) {
 function bindBlock(block, ctx) {
 	const descriptor = findBlockDescriptor(ctx.pslBlockDescriptors, block.keyword);
 	if (descriptor === void 0) return;
-	const spec = blockSpecFactoryOf(descriptor)({
-		symbols: ctx.symbolTable,
-		block
-	});
+	const spec = blockSpecFactoryOf(descriptor)({ symbols: ctx.symbolTable });
 	for (const entry of block.node.entries()) {
 		const key = entry.key()?.name();
 		if (key === void 0) continue;
@@ -448,10 +534,7 @@ function bindBlock(block, ctx) {
 	for (const attribute of readResolvedAttributes(block.node.attributes(), ctx.sources)) {
 		const factory = attributeSpecs[attribute.name];
 		if (factory === void 0) continue;
-		bindArguments(attribute, blindCast(factory)({
-			symbols: ctx.symbolTable,
-			block
-		}), ctx);
+		bindArguments(attribute, blindCast(factory)({ symbols: ctx.symbolTable }), ctx);
 	}
 }
 function bindExpression(rule, expression, ctx, modelContext) {
@@ -527,14 +610,14 @@ function tryBindExpression(rule, expression, ctx, modelContext) {
 		}
 		case "entityRef": {
 			const node = expression.syntax;
-			const name = IdentifierAst.cast(node)?.name();
-			if (name === void 0) return {
+			const written = writtenEntityReference(node);
+			if (written === void 0) return {
 				matched: false,
 				references,
 				diagnostics
 			};
 			const failures = [];
-			const resolution = resolveEntity(name, node, {
+			const resolution = resolveEntity(written, node, {
 				...ctx,
 				diagnostics: failures
 			});
@@ -683,15 +766,23 @@ function targetFields(target) {
 	if (target === void 0) return void 0;
 	if (target.kind === "model" || target.kind === "compositeType") return target.symbol.fields;
 }
-function resolveEntity(name, node, ctx) {
-	const found = ctx.scope.lookup(name);
+function resolveEntity(written, node, ctx) {
+	const found = written.namespace === void 0 ? ctx.scope.lookup(written.name) : qualifiedMember(written.namespace, written.name, ctx.scope);
 	if (found === void 0) {
-		report(`Cannot find entity "${name}"`, node, ctx, "entity");
+		const name = describeWrittenEntityReference(written);
+		if (written.name !== "") report(`Cannot find entity "${name}"`, node, ctx, "entity");
 		return {
 			kind: "unresolved",
 			name
 		};
 	}
+	if ("badQualifier" in found) {
+		report(found.badQualifier, node, ctx, "entity");
+		return {
+			kind: "unresolved",
+			name: found.qualifier
+		};
+	}
 	return found;
 }
 function report(message, node, ctx, reference) {
@@ -1032,40 +1123,6 @@ function bool() {
 		}
 	};
 }
-const references = /* @__PURE__ */ new WeakMap();
-function entityReference(resolution) {
-	switch (resolution.kind) {
-		case "model":
-		case "compositeType":
-		case "namedType":
-		case "block": return interned(resolution.symbol, resolution.namespace);
-		default: return;
-	}
-}
-function interned(declaration, namespace) {
-	const existing = references.get(declaration);
-	if (existing !== void 0) return existing;
-	const reference = {
-		declaration,
-		namespace
-	};
-	references.set(declaration, reference);
-	return reference;
-}
-function matchesSelector(reference, expected) {
-	const declaration = reference.declaration;
-	if (declaration.kind !== expected.kind) return false;
-	return expected.kind !== "block" || declaration.kind === "block" && declaration.keyword === expected.keyword;
-}
-function describeResolution(resolution) {
-	switch (resolution.kind) {
-		case "block": return resolution.symbol.keyword;
-		case "contributedType": return "scalar type";
-		case "crossSpace": return "cross-space reference";
-		case "unresolved": return "unresolved name";
-		default: return resolution.kind;
-	}
-}
 function entityRef(expected) {
 	const label = `${expected.kind === "block" ? expected.keyword : expected.kind} reference`;
 	return {
@@ -1073,8 +1130,9 @@ function entityRef(expected) {
 		label,
 		expected,
 		parse: (arg, ctx) => {
-			const name = IdentifierAst.cast(arg.syntax)?.name();
-			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
+			const written = writtenEntityReference(arg.syntax);
+			if (written === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
+			const name = describeWrittenEntityReference(written);
 			const resolution = ctx.binder.symbolForNode(arg.syntax);
 			if (resolution === void 0 || resolution.kind === "unresolved") return notOk([]);
 			const reference = entityReference(resolution);
@@ -1556,7 +1614,8 @@ function interpretExtensionBlock(input) {
 	const ctx = {
 		sources,
 		symbols,
-		binder
+		binder,
+		selfBlock: block
 	};
 	const entries = spec.mode === "struct" ? interpretStructBlock(block, spec, ctx) : interpretMapBlock(block, spec, ctx);
 	const diagnostics = [...entries.diagnostics];
@@ -1698,14 +1757,12 @@ function interpretExtensionBlockAttributes(input) {
 			continue;
 		}
 		seenNames.add(name);
-		const spec = blindCast(declared[name])({
-			symbols,
-			block
-		});
+		const spec = blindCast(declared[name])({ symbols });
 		const result = interpretAttribute(attribute, spec, {
 			sources,
 			symbols,
-			binder
+			binder,
+			selfBlock: block
 		});
 		if (result.ok) {
 			const argSpans = Object.create(null);
@@ -1744,10 +1801,7 @@ function interpretExtensionBlocks(input) {
 		const parsed = interpretExtensionBlock({
 			block,
 			descriptor,
-			spec: blockSpecFactoryOf(descriptor)({
-				symbols: symbolTable,
-				block
-			}),
+			spec: blockSpecFactoryOf(descriptor)({ symbols: symbolTable }),
 			symbols: symbolTable,
 			sources,
 			binder