astn 0.110.16 → 1.20.5

package/server/src/server.ts

@@ -0,0 +1,296 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+import {
+	createConnection,
+	TextDocuments,
+	Diagnostic,
+	DiagnosticSeverity,
+	ProposedFeatures,
+	InitializeParams,
+	DidChangeConfigurationNotification,
+	CompletionItem,
+	CompletionItemKind,
+	TextDocumentPositionParams,
+	TextDocumentSyncKind,
+	InitializeResult,
+	DocumentDiagnosticReportKind,
+	Position,
+	type DocumentDiagnosticReport,
+} from 'vscode-languageserver/node';
+
+import * as vscode_types from 'vscode-languageserver-types';
+
+
+import {
+	TextDocument
+} from 'vscode-languageserver-textdocument';
+
+
+import { $ as be } from "./backend"
+
+
+import * as backend from "../../backend/dist"
+
+// Create a connection for the server, using Node's IPC as a transport.
+// Also include all preview / proposed LSP features.
+const connection = createConnection(ProposedFeatures.all);
+
+// Create a simple text document manager.
+const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
+
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+let hasDiagnosticRelatedInformationCapability = false;
+
+connection.onInitialize((params: InitializeParams) => {
+	const capabilities = params.capabilities;
+
+	// Does the client support the `workspace/configuration` request?
+	// If not, we fall back using global settings.
+	hasConfigurationCapability = !!(
+		capabilities.workspace && !!capabilities.workspace.configuration
+	);
+	hasWorkspaceFolderCapability = !!(
+		capabilities.workspace && !!capabilities.workspace.workspaceFolders
+	);
+	hasDiagnosticRelatedInformationCapability = !!(
+		capabilities.textDocument &&
+		capabilities.textDocument.publishDiagnostics &&
+		capabilities.textDocument.publishDiagnostics.relatedInformation
+	);
+
+	const result: InitializeResult = {
+		capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			// Tell the client that this server supports code completion.
+			completionProvider: {
+				resolveProvider: true
+			},
+			diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false
+			},
+			hoverProvider: true,
+		}
+	};
+	if (hasWorkspaceFolderCapability) {
+		result.capabilities.workspace = {
+			workspaceFolders: {
+				supported: true
+			}
+		};
+	}
+	return result;
+});
+
+connection.onInitialized(() => {
+	if (hasConfigurationCapability) {
+		// Register for all configuration changes.
+		connection.client.register(DidChangeConfigurationNotification.type, undefined);
+	}
+	if (hasWorkspaceFolderCapability) {
+		connection.workspace.onDidChangeWorkspaceFolders(_event => {
+			connection.console.log('Workspace folder change event received.');
+		});
+	}
+});
+
+// The example settings
+interface ExampleSettings {
+	maxNumberOfProblems: number;
+}
+
+// The global settings, used when the `workspace/configuration` request is not supported by the client.
+// Please note that this is not the case when using this server with the client provided in this example
+// but could happen with other clients.
+const defaultSettings: ExampleSettings = { maxNumberOfProblems: 1000 };
+let globalSettings: ExampleSettings = defaultSettings;
+
+// Cache the settings of all open documents
+const documentSettings: Map<string, Thenable<ExampleSettings>> = new Map();
+
+connection.onDidChangeConfiguration(change => {
+	if (hasConfigurationCapability) {
+		// Reset all cached document settings
+		documentSettings.clear();
+	} else {
+		globalSettings = <ExampleSettings>(
+			(change.settings.languageServerExample || defaultSettings)
+		);
+	}
+	// Refresh the diagnostics since the `maxNumberOfProblems` could have changed.
+	// We could optimize things here and re-fetch the setting first can compare it
+	// to the existing setting, but this is out of scope for this example.
+	connection.languages.diagnostics.refresh();
+});
+
+function getDocumentSettings(resource: string): Thenable<ExampleSettings> {
+	if (!hasConfigurationCapability) {
+		return Promise.resolve(globalSettings);
+	}
+	let result = documentSettings.get(resource);
+	if (!result) {
+		result = connection.workspace.getConfiguration({
+			scopeUri: resource,
+			section: 'languageServerExample'
+		});
+		documentSettings.set(resource, result);
+	}
+	return result;
+}
+
+// Only keep settings for open documents
+documents.onDidClose(e => {
+	documentSettings.delete(e.document.uri);
+});
+
+
+connection.languages.diagnostics.on(async (params) => {
+	const document = documents.get(params.textDocument.uri);
+	if (document !== undefined) {
+		return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: await validateTextDocument(document)
+		} satisfies DocumentDiagnosticReport;
+	} else {
+		// We don't know the document. We can either try to read it from disk
+		// or we don't report problems for it.
+		return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: []
+		} satisfies DocumentDiagnosticReport;
+	}
+});
+
+// The content of a text document has changed. This event is emitted
+// when the text document first opened or when its content has changed.
+documents.onDidChangeContent(change => {
+	validateTextDocument(change.document);
+});
+
+// const create_vscode_position = (position: backend.Relative_Location): vscode_types.Position => {
+// 	return new Position(position.line, position.column);
+// }
+
+const create_vscode_range = (backend_range: backend.Range): vscode_types.Range => {
+	return vscode_types.Range.create(
+		backend_range.start.relative.line,
+		backend_range.start.relative.column,
+		backend_range.end.relative.line,
+		backend_range.end.relative.column
+	)
+}
+
+async function validateTextDocument(textDocument: TextDocument): Promise<Diagnostic[]> {
+	// In this simple example we get the settings for every validate run.
+	return new Promise<Diagnostic[]>((resolve, reject) => {
+
+		be.validateTextDocument(
+			{
+				uri: textDocument.uri,
+				content: textDocument.getText(),
+			},
+			{
+				'tab size': 1 // vscode works with character, not with columns
+			},
+			($) => {
+				resolve($.diagnostics.map(($) => ({
+					severity: (() => {
+						switch ($.severity[0]) {
+							case "error": return DiagnosticSeverity.Error
+							case "warning": return DiagnosticSeverity.Warning
+							case "information": return DiagnosticSeverity.Information
+							case "hint": return DiagnosticSeverity.Hint
+						}
+					})(),
+					message: $.message,
+					range: create_vscode_range($.range),
+				})))
+	
+			}
+		)
+	})
+}
+
+connection.onDidChangeWatchedFiles(_change => {
+	// Monitored files have change in VSCode
+	connection.console.log('We received a file change event');
+});
+
+// This handler provides the initial list of the completion items.
+connection.onCompletion(
+	(_textDocumentPosition: TextDocumentPositionParams): CompletionItem[] => {
+		// The pass parameter contains the position of the text document in
+		// which code complete got requested. For the example we ignore this
+		// info and always provide the same completion items.
+		return [
+			{
+				label: 'TypeScript',
+				kind: CompletionItemKind.Text,
+				data: 1
+			},
+			{
+				label: 'JavaScript',
+				kind: CompletionItemKind.Text,
+				data: 2
+			}
+		];
+	}
+);
+
+// This handler resolves additional information for the item selected in
+// the completion list.
+connection.onCompletionResolve(
+	(item: CompletionItem): CompletionItem => {
+		if (item.data === 1) {
+			item.detail = 'TypeScript details';
+			item.documentation = 'TypeScript documentation';
+		} else if (item.data === 2) {
+			item.detail = 'JavaScript details';
+			item.documentation = 'JavaScript documentation';
+		}
+		return item;
+	}
+);
+
+connection.onHover(
+	(hoverParams, cancellationToken, workdoneProgress, resultProgress) => {
+		// The pass parameter contains the position of the text document in
+		// which code complete got requested.
+
+		const doc = documents.get(hoverParams.textDocument.uri)
+		if (doc === undefined) {
+			return null
+		}
+
+		return new Promise(
+			(resolve) => {
+				be.onHover(
+					{
+						document: {
+							uri: hoverParams.textDocument.uri,
+							content: doc.getText(),
+						},
+						offset: doc.offsetAt(Position.create(hoverParams.position.line, hoverParams.position.character,)),
+
+					},
+					($) => {
+						resolve({
+							contents: $.hovertexts
+						})
+
+					}
+				)
+			},
+		)
+	}
+)
+
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+// Listen on the connection
+connection.listen();

package/server/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "es2020",
+		"lib": ["es2020"],
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"sourceMap": true,
+		"strict": true,
+		"outDir": "out",
+		"rootDir": "src"
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", ".vscode-test"]
+}

package/server/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/backend.ts","./src/backendapi.ts","./src/server.ts"],"errors":true,"version":"5.6.3"}

package/syntaxes/astn.tmLanguage.json

@@ -0,0 +1,320 @@
+{
+	"name": "astn",
+	"scopeName": "source.astn",
+	"patterns": [
+		{
+			"match": "!",
+			"name": "punctuation.definition.header.astn support.type.singular_structural_token.astn"
+		},
+		{
+			"include": "#comment_or_value"
+		},
+		{
+			"match": "[^\\s\\}]",
+			"name": "invalid.illegal.unexpected-root-token.astn"
+		}
+	],
+	"repository": {
+		"comment_or_value": {
+			"patterns": [
+				{
+					"include": "#comment"
+				},
+				{
+					"include": "#value"
+				}
+			]
+		},
+		"comment": {
+			"patterns": [
+				{
+					"begin": "/\\*\\*(?!/)",
+					"captures": {
+						"0": {
+							"name": "punctuation.definition.comment.astn"
+						}
+					},
+					"end": "\\*/",
+					"name": "comment.block.documentation.astn"
+				},
+				{
+					"begin": "/\\*",
+					"captures": {
+						"0": {
+							"name": "punctuation.definition.comment.astn"
+						}
+					},
+					"end": "\\*/",
+					"name": "comment.block.astn"
+				},
+				{
+					"captures": {
+						"1": {
+							"name": "punctuation.definition.comment.astn"
+						}
+					},
+					"match": "(//).*$\\n?",
+					"name": "comment.line.double-slash.js"
+				}
+			]
+		},
+		"value": {
+			"patterns": [
+				{
+					"include": "#concise_group"
+				},
+				{
+					"include": "#dictionary"
+				},
+				{
+					"include": "#list"
+				},
+				{
+					"include": "#verbose_group"
+				},
+				{
+					"match": "\\|",
+					"name": "punctuation.separator.tagged_value.astn support.type.singular_structural_token.astn"
+				},
+				{
+					"match": "\\@",
+					"name": "punctuation.separator.include.ast support.type.singular_structural_token.astn"
+				},
+				{
+					"match": "\\~",
+					"name": "punctuation.separator.no_value.astn support.type.singular_structural_token.astn"
+				},
+				{
+					"match": "\\*",
+					"name": "punctuation.separator.set_value.astn support.type.singular_structural_token.astn"
+				},
+				{
+					"include": "#string"
+				}
+			]
+		},
+		"concise_group": {
+			"begin": "\\<",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.concise_group.begin.astn"
+				}
+			},
+			"end": "\\>",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.concise_group.end.astn"
+				}
+			},
+			"name": "meta.structure.concise_group.astn",
+			"patterns": [
+				{
+					"include": "#comment_or_value"
+				},
+				{
+					"match": ",",
+					"name": "punctuation.separator.comma.concise_group.astn"
+				},
+				{
+					"match": "[^\\s\\]]",
+					"name": "invalid.illegal.expected-concise_group-separator-or-end.astn"
+				}
+			]
+		},
+		"dictionary": {
+			"begin": "\\{",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.dictionary.begin.astn"
+				}
+			},
+			"end": "\\}",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.dictionary.end.astn"
+				}
+			},
+			"name": "meta.structure.dictionary.astn",
+			"patterns": [
+				{
+					"include": "#comment_or_value"
+				},
+				{
+					"match": ",",
+					"name": "punctuation.separator.comma.dictionary.astn"
+				},
+				{
+					"match": ":",
+					"name": "punctuation.separator.colon.dictionary.astn"
+				},
+				{
+					"match": "[^\\s\\}]",
+					"name": "invalid.illegal.expected-dictionary-separator-or-end.astn"
+				}
+			]
+		},
+		"string": {
+			"patterns": [
+				{
+					"include": "#quoted_string"
+				},
+				{
+					"include": "#backticked_string"
+				},
+				{
+					"include": "#apostrophed_string"
+				},
+				{
+					"include": "#undelimited_string"
+				}
+			]
+		},
+		"list": {
+			"begin": "\\[",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.list.begin.astn"
+				}
+			},
+			"end": "\\]",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.list.end.astn"
+				}
+			},
+			"name": "meta.structure.list.astn",
+			"patterns": [
+				{
+					"include": "#comment_or_value"
+				},
+				{
+					"match": ",",
+					"name": "punctuation.separator.comma.list.astn"
+				},
+				{
+					"match": "[^\\s\\]]",
+					"name": "invalid.illegal.expected-list-separator-or-end.astn"
+				}
+			]
+		},
+		"verbose_group": {
+			"begin": "\\(",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.verbose_group.begin.astn"
+				}
+			},
+			"end": "\\)",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.verbose_group.end.astn"
+				}
+			},
+			"name": "meta.structure.type.astn",
+			"patterns": [
+				{
+					"include": "#comment_or_value"
+				},
+				{
+					"match": ",",
+					"name": "punctuation.separator.comma.verbose_group.astn"
+				},
+				{
+					"match": ":",
+					"name": "punctuation.separator.colon.verbose_group.astn"
+				},
+				{
+					"match": "[^\\s\\}]",
+					"name": "invalid.illegal.expected-verbose_group-separator-or-end.astn"
+				}
+			]
+		},
+		"quoted_string": {
+			"begin": "\"",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.definition.string.quote.begin.astn"
+				}
+			},
+			"end": "\"",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.definition.string.quote.end.astn"
+				}
+			},
+			"name": "string.quoted.double.astn",
+			"patterns": [
+				{
+					"match": "[^\"\\\\]+",
+					"name": "string.unescaped.content"
+				},
+				{
+					"match": "\\\\.",
+					"name": "constant.character.escape"
+				}
+			]
+		},
+		"apostrophed_string": {
+			"begin": "'",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.support.type.apostrophed_string.astn"
+				}
+			},
+			"end": "'",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.support.type.apostrophed_string.astn"
+				}
+			},
+			"name": "string.astn support.type.apostrophed_string.astn",
+			"patterns": [
+				{
+					"match": "[^'\\\\]+",
+					"name": "string.unescaped.content support.type.apostrophed_string.astn"
+				},
+				{
+					"match": "\\\\.",
+					"name": "constant.character.escape support.type.apostrophed_string.astn"
+				},
+				{
+					"match": "\\n",
+					"name": "invalid.illegal.newline_in_apostrophed_string.astn"
+				}
+			]
+		},
+		"backticked_string": {
+			"begin": "`",
+			"beginCaptures": {
+				"0": {
+					"name": "punctuation.support.type.backticked_string.astn"
+				}
+			},
+			"end": "`",
+			"endCaptures": {
+				"0": {
+					"name": "punctuation.support.type.backticked_string.astn"
+				}
+			},
+			"name": "string.astn support.type.backticked_string.astn",
+			"patterns": [
+				{
+					"match": "[^`\\\\]+",
+					"name": "string.unescaped.content support.type.backticked_string.astn"
+				},
+				{
+					"match": "\\\\.",
+					"name": "constant.character.escape support.type.backticked_string.astn"
+				},
+				{
+					"match": "\\n",
+					"name": "invalid.illegal.newline_in_backticked_string.astn"
+				}
+			]
+		},
+		"undelimited_string": {
+			"match": "[^\\s\\[\\]\\{\\}\\(\\)\\<\\>\\|\\@\\~\\*\"'`]+",
+			"name": "string.unquoted.astn support.type.undelimited_string.astn"
+		}
+	}
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "es2020",
+		"lib": ["es2020"],
+		"outDir": "out",
+		"rootDir": "src",
+		"sourceMap": true
+	},
+	"include": [
+		"src"
+	],
+	"exclude": [
+		"node_modules",
+		".vscode-test"
+	],
+	"references": [
+		{ "path": "./client" },
+		{ "path": "./server" }
+	]
+}

package/LICENSE

@@ -1,17 +0,0 @@
-Apache License  
-Version 2.0, January 2004  
-http://www.apache.org/licenses/
-
-Copyright (c) 2025 Corno
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

package/dist/bin/convert_to_json.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};