Refactoring: Define Blocktypes solely in Code

apps/vs-code-extension/src/language-server.ts

@@ -2,20 +2,14 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-only
 
-import { StdLangExtension } from '@jvalue/jayvee-extensions/std/lang';
-import {
-  createJayveeServices,
-  useExtension,
-} from '@jvalue/jayvee-language-server';
+import { createJayveeServices } from '@jvalue/jayvee-language-server';
 import { startLanguageServer } from 'langium';
 import { NodeFileSystem } from 'langium/node';
 import { ProposedFeatures, createConnection } from 'vscode-languageserver/node';
 
 // Create a connection to the client
 const connection = createConnection(ProposedFeatures.all);
 
-useExtension(new StdLangExtension());
-
 // Inject the shared services and language-specific services
 const { shared } = createJayveeServices({
   connection,

apps/vs-code-extension/src/standard-library-file-system-provider.ts

@@ -2,11 +2,7 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-only
 
-import { StdLangExtension } from '@jvalue/jayvee-extensions/std/lang';
-import {
-  getStdLib,
-  useExtension as useLangExtension,
-} from '@jvalue/jayvee-language-server';
+import { getStdLib, registerConstraints } from '@jvalue/jayvee-language-server';
 import {
   EventEmitter,
   ExtensionContext,
@@ -33,7 +29,7 @@ export class StandardLibraryFileSystemProvider implements FileSystemProvider {
   private registerStdLib() {
     // The VSCode Extension needs to register the StdLangExtension,
     // otherwise the StdLib does not include the blocktype definitions.
-    useLangExtension(new StdLangExtension());
+    registerConstraints();
 
     Object.entries(getStdLib()).forEach(([libName, lib]) => {
       this.libraries.set(

example/test.jv

@@ -0,0 +1,19 @@
+/*
+Interprets an input file as a csv-file containing string-values delimited by `delimiter` and outputs a `Sheet`.
+
+@example Interprets an input file as a csv-file containing string-values delimited by `;` and outputs `Sheet`.
+block AgencyCSVInterpreter oftype CSVInterpreter {  
+    delimiter: ";";
+  }
+*/
+builtin blocktype CSVInterpreter {
+	input default oftype TextFile;
+	output default oftype Sheet;
+
+	// The delimiter for values in the CSV file.
+	property delimiter oftype text: ',';
+	// The enclosing character that may be used for values in the CSV file.
+	property enclosing oftype text: '';
+	// The character to escape enclosing characters in values.
+	property enclosingEscape oftype text: '';
+}

libs/execution/src/lib/constraints/constraint-executor-registry.ts

@@ -46,7 +46,8 @@ export function createConstraintExecutor(
   constraint: ConstraintDefinition,
 ): ConstraintExecutor {
   if (isTypedConstraintDefinition(constraint)) {
-    const constraintType = constraint.type.name;
+    const constraintType = constraint.type.ref?.name;
+    assert(constraintType !== undefined);
     const constraintExecutor = constraintExecutorRegistry.get(constraintType);
     assert(
       constraintExecutor !== undefined,

libs/execution/src/lib/execution-context.ts

@@ -6,23 +6,24 @@ import { strict as assert } from 'assert';
 
 import {
   BlockDefinition,
+  BlockMetaInformation,
   ConstraintDefinition,
   EvaluationContext,
   InternalValueRepresentation,
-  MetaInformation,
   PipelineDefinition,
   PropertyAssignment,
   TransformDefinition,
   Valuetype,
   evaluatePropertyValue,
-  getOrFailMetaInformation,
-  isConstraintDefinition,
+  getOrFailConstraintMetaInf,
+  isBlockDefinition,
   isExpressionConstraintDefinition,
   isPipelineDefinition,
   isPropertyBody,
   isTransformDefinition,
+  isTypedConstraintDefinition,
 } from '@jvalue/jayvee-language-server';
-import { isReference } from 'langium';
+import { assertUnreachable, isReference } from 'langium';
 
 import {
   DebugGranularity,
@@ -145,13 +146,13 @@ export class ExecutionContext {
     assert(!isExpressionConstraintDefinition(currentNode));
     assert(!isTransformDefinition(currentNode));
 
-    let metaInf: MetaInformation;
-    if (isConstraintDefinition(currentNode)) {
-      metaInf = getOrFailMetaInformation(currentNode.type);
-    } else {
+    if (isTypedConstraintDefinition(currentNode)) {
+      return getOrFailConstraintMetaInf(currentNode.type);
+    } else if (isBlockDefinition(currentNode)) {
       assert(isReference(currentNode.type));
-      metaInf = getOrFailMetaInformation(currentNode.type);
+      assert(BlockMetaInformation.canBeWrapped(currentNode.type));
+      return new BlockMetaInformation(currentNode.type);
     }
-    return metaInf;
+    assertUnreachable(currentNode);
   }
 }