0.1.0

Author: ikasoba

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.dist/

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "aiscript"]
+	path = aiscript
+	url = https://github.com/aiscript-dev/aiscript
+	branch = aiscript-next

aiscript

@@ -0,0 +1,12 @@
+import {
+  createConnection,
+  ProposedFeatures,
+} from "vscode-languageserver/node.js";
+import { LanguageServer } from "../core/server/LanguageServer.js";
+import { initAiScriptI18n } from "../core/i18n/aiscript/index.js";
+
+const i18n = initAiScriptI18n("ja");
+
+const server = new LanguageServer(i18n, createConnection(ProposedFeatures.all));
+
+server.listen();

features/cli/index.ts

@@ -0,0 +1,55 @@
+import { Token } from "@syuilo/aiscript/parser/token.js";
+import { SourceLocation } from "../parser/SourceRange.js";
+import { Ast } from "@syuilo/aiscript";
+
+export enum AiSyntaxErrorId {
+  invalidAttribute,
+  UnExpectedToken,
+  MultipleStatementsOnSingleLine,
+  MissingThenClause,
+  MissingCondition,
+  SeparatorExpected,
+  NonNumericSign,
+  CanNotUseSpacesInReference,
+  MissingIdentifier,
+  MissingType,
+  MissingParams,
+  MissingFunctionBody,
+  MissingExpr,
+  MissingKeyword,
+  MissingBody,
+  MissingBracket,
+  MissingAttribute,
+  MissingLineBreak,
+  MissingStatement,
+}
+
+export class AiSyntaxError extends Error {
+  constructor(
+    public messageId: AiSyntaxErrorId,
+    public token: Token | Ast.Node,
+    public location: SourceLocation,
+  ) {
+    super(AiSyntaxErrorId[messageId]);
+  }
+}
+
+export class AiMissingKeywordError extends AiSyntaxError {
+  constructor(
+    public keyword: string,
+    token: Token | Ast.Node,
+    location: SourceLocation,
+  ) {
+    super(AiSyntaxErrorId.MissingKeyword, token, location);
+  }
+}
+
+export class AiMissingBracketError extends AiSyntaxError {
+  constructor(
+    public bracket: string,
+    token: Token | Ast.Node,
+    location: SourceLocation,
+  ) {
+    super(AiSyntaxErrorId.MissingBracket, token, location);
+  }
+}

features/core/errors/AiSyntaxError.ts

@@ -0,0 +1,66 @@
+import { I18nLocalizer } from "../index.js";
+import { SourceLocation } from "../parser/SourceRange.js";
+
+export enum AiTypeErrorKind {
+  AlreadyDeclaredVariable,
+  NotAssignableType,
+  CanNotCall,
+  MissingArgumentError,
+  InvalidArgumentError,
+  CanNotAssignToImmutableVariable,
+}
+
+export class AiTypeError extends Error {
+  constructor(public kind: AiTypeErrorKind, public location: SourceLocation) {
+    super(AiTypeErrorKind[kind]);
+  }
+}
+
+export class AiAlreadyDeclaredVariableError extends AiTypeError {
+  constructor(public name: string, location: SourceLocation) {
+    super(AiTypeErrorKind.AlreadyDeclaredVariable, location);
+  }
+}
+
+export class AiNotAssignableTypeError extends AiTypeError {
+  constructor(
+    public left: string,
+    public right: string,
+    location: SourceLocation
+  ) {
+    super(AiTypeErrorKind.NotAssignableType, location);
+  }
+}
+
+export class AiCanNotCallError extends AiTypeError {
+  constructor(public type: string, location: SourceLocation) {
+    super(AiTypeErrorKind.CanNotCall, location);
+  }
+}
+
+export class AiMissingArgumentError extends AiTypeError {
+  constructor(
+    public pos: number,
+    public expectType: string,
+    location: SourceLocation
+  ) {
+    super(AiTypeErrorKind.MissingArgumentError, location);
+  }
+}
+
+export class AiInvalidArgumentError extends AiTypeError {
+  constructor(
+    public pos: number,
+    public expectType: string,
+    public butType: string,
+    location: SourceLocation
+  ) {
+    super(AiTypeErrorKind.InvalidArgumentError, location);
+  }
+}
+
+export class AiCanNotAssignToImmutableVariableError extends AiTypeError {
+  constructor(public name: string, location: SourceLocation) {
+    super(AiTypeErrorKind.CanNotAssignToImmutableVariable, location);
+  }
+}

features/core/errors/AiTypeError.ts

@@ -0,0 +1,28 @@
+import {
+  AiMissingBracketError,
+  AiMissingKeywordError,
+  AiSyntaxError,
+} from "./AiSyntaxError.js";
+import {
+  AiAlreadyDeclaredVariableError,
+  AiTypeError,
+  AiNotAssignableTypeError,
+  AiCanNotCallError,
+  AiMissingArgumentError,
+  AiInvalidArgumentError,
+  AiCanNotAssignToImmutableVariableError,
+} from "./AiTypeError.js";
+
+export type ParserError =
+  | AiSyntaxError
+  | AiMissingKeywordError
+  | AiMissingBracketError;
+
+export type TypeError =
+  | AiTypeError
+  | AiAlreadyDeclaredVariableError
+  | AiNotAssignableTypeError
+  | AiCanNotCallError
+  | AiMissingArgumentError
+  | AiInvalidArgumentError
+  | AiCanNotAssignToImmutableVariableError;

features/core/errors/index.ts

@@ -0,0 +1,15 @@
+import { I18n } from "../core.js";
+import { syntaxErrorMessage } from "./syntaxError.js";
+import { typeErrorMessage } from "./typeError.js";
+
+export const initAiScriptI18n = <L extends "ja">(lang: L) =>
+  new I18n(lang, {
+    syntax: syntaxErrorMessage,
+    typing: typeErrorMessage,
+  });
+
+export type AiScriptI18n = ReturnType<typeof initAiScriptI18n>;
+
+export type AiScriptI18nMessages = AiScriptI18n extends I18n<any, infer T>
+  ? T
+  : never;

features/core/i18n/aiscript/index.ts

@@ -0,0 +1,112 @@
+import {
+  AiMissingBracketError,
+  AiMissingKeywordError,
+  AiSyntaxErrorId,
+} from "../../errors/AiSyntaxError.js";
+import { ParserError } from "../../errors/index.js";
+import { Enum2Name } from "../../utils/type.js";
+import {
+  I18n,
+  I18nLangs,
+  I18nLocalizerResult,
+  I18nMessage,
+  I18nMessages,
+  I18nPath,
+} from "../core.js";
+import { AiScriptI18nMessages } from "./index.js";
+
+export const syntaxErrorMessage = {
+  ja: {
+    invalidAttribute() {
+      return "不正なAttributeです。";
+    },
+    UnExpectedToken() {
+      return `予期しないトークンが現れました。`;
+    },
+    MultipleStatementsOnSingleLine() {
+      return "複数のステートメントは同じ行に置くことはできません。";
+    },
+    MissingThenClause() {
+      return "if文にはthen節が必要です。";
+    },
+    MissingCondition() {
+      return "if文には条件が必要です。";
+    },
+    SeparatorExpected() {
+      return "セパレーターが必要です。";
+    },
+    NonNumericSign() {
+      return "数値以外にはこの演算子は使えません。";
+    },
+    CanNotUseSpacesInReference() {
+      return "識別子に空白は使用できません。";
+    },
+    MissingIdentifier() {
+      return "識別子が必要です。";
+    },
+    MissingType() {
+      return "型が必要です。";
+    },
+    MissingParams() {
+      return "引数部分が必要です。";
+    },
+    MissingFunctionBody() {
+      return "関数には内容が必要です。";
+    },
+    MissingExpr() {
+      return "式が必要です。";
+    },
+    MissingKeyword(name: string) {
+      return `\`${name}\`キーワードが必要です。`;
+    },
+    MissingBody() {
+      return `コードブロックが必要です。`;
+    },
+    MissingBracket(bracket: string) {
+      return `\`${bracket}\`が必要です。`;
+    },
+    MissingAttribute() {
+      return "Attributeが必要です。";
+    },
+    MissingLineBreak() {
+      return "改行が必要です。";
+    },
+    MissingStatement() {
+      return "ステートメントが必要です。";
+    },
+  } satisfies I18nMessage<keyof typeof AiSyntaxErrorId>,
+} satisfies I18nMessages;
+
+export const parserErrorLocalizer = (
+  err: ParserError
+): I18nLocalizerResult<AiScriptI18nMessages> => {
+  if (err instanceof AiMissingBracketError) {
+    return ["syntax.MissingBracket", [err.bracket]];
+  } else if (err instanceof AiMissingKeywordError) {
+    return ["syntax.MissingKeyword", [err.keyword]];
+  }
+
+  switch (err.messageId) {
+    case AiSyntaxErrorId.MissingBracket: {
+      return ["syntax.MissingBracket", ["<unknown>"]];
+    }
+
+    case AiSyntaxErrorId.MissingKeyword: {
+      return ["syntax.MissingKeyword", ["<unknown>"]];
+    }
+
+    default: {
+      const id = err.messageId as Exclude<
+        typeof err.messageId,
+        AiSyntaxErrorId.MissingBracket | AiSyntaxErrorId.MissingKeyword
+      >;
+
+      return [
+        `syntax.${
+          AiSyntaxErrorId[id] as Enum2Name<typeof AiSyntaxErrorId, typeof id>
+        }`,
+        [],
+      ];
+    }
+  }
+};

features/core/i18n/aiscript/syntaxError.ts

@@ -0,0 +1,79 @@
+import {
+  AiAlreadyDeclaredVariableError,
+  AiCanNotAssignToImmutableVariableError,
+  AiCanNotCallError,
+  AiInvalidArgumentError,
+  AiMissingArgumentError,
+  AiNotAssignableTypeError,
+  AiTypeErrorKind,
+} from "../../errors/AiTypeError.js";
+import { TypeError } from "../../index.js";
+import { I18nLocalizerResult, I18nMessage, I18nMessages } from "../core.js";
+import { AiScriptI18nMessages } from "./index.js";
+
+export const typeErrorMessage = {
+  ja: {
+    NotAssignableType(dest: string, value: string) {
+      return `型\`${dest}\`に、\`${value}\`は代入できません。`;
+    },
+    AlreadyDeclaredVariable(name: string) {
+      return `変数\`${name}\`はすでに定義されています。`;
+    },
+    CanNotCall(type: string) {
+      return `型\`${type}\`は関数型ではありません。`;
+    },
+    InvalidArgumentError(pos: number, dest: string, but: string) {
+      return `${pos}番目の引数には型\`${dest}\`が必要ですが、\`${but}\`が与えられました。`;
+    },
+    MissingArgumentError(pos: number, dest: string) {
+      return `${pos}番目の引数には型\`${dest}\`が必要ですが、何も与えられていません。`;
+    },
+    CanNotAssignToImmutableVariable(name: string) {
+      return `変数\`${name}\`は不変なので、新たに代入することはできません。`;
+    },
+  } satisfies I18nMessage<keyof typeof AiTypeErrorKind>,
+} satisfies I18nMessages;
+
+export const typeErrorLocalizer = (
+  error: TypeError
+): I18nLocalizerResult<AiScriptI18nMessages> => {
+  if (error instanceof AiNotAssignableTypeError) {
+    return ["typing.NotAssignableType", [error.left, error.right]];
+  } else if (error instanceof AiAlreadyDeclaredVariableError) {
+    return ["typing.AlreadyDeclaredVariable", [error.name]];
+  } else if (error instanceof AiCanNotCallError) {
+    return ["typing.CanNotCall", [error.type]];
+  } else if (error instanceof AiInvalidArgumentError) {
+    return [
+      "typing.InvalidArgumentError",
+      [error.pos, error.expectType, error.butType],
+    ];
+  } else if (error instanceof AiMissingArgumentError) {
+    return ["typing.MissingArgumentError", [error.pos, error.expectType]];
+  } else if (error instanceof AiCanNotAssignToImmutableVariableError) {
+    return ["typing.CanNotAssignToImmutableVariable", [error.name]];
+  }
+
+  switch (error.kind) {
+    case AiTypeErrorKind.AlreadyDeclaredVariable:
+      return ["typing.AlreadyDeclaredVariable", ["<:unknown:>"]];
+
+    case AiTypeErrorKind.NotAssignableType:
+      return ["typing.NotAssignableType", ["<:unknown:>", "<:unknown:>"]];
+
+    case AiTypeErrorKind.CanNotCall:
+      return ["typing.CanNotCall", ["<:unknown:>"]];
+
+    case AiTypeErrorKind.InvalidArgumentError:
+      return [
+        "typing.InvalidArgumentError",
+        [-1, "<:unknown:>", "<:unknown:>"],
+      ];
+
+    case AiTypeErrorKind.MissingArgumentError:
+      return ["typing.MissingArgumentError", [-1, "<:unknown:>"]];
+
+    case AiTypeErrorKind.CanNotAssignToImmutableVariable:
+      return ["typing.CanNotAssignToImmutableVariable", ["<:unknown:>"]];
+  }
+};