build: separate module for frontend

This allows us to simplify the webpack configuration and the gradle
build scripts.

5 files changed, 450 insertions, 0 deletions

diff --git a/subprojects/frontend/src/language/folding.ts b/subprojects/frontend/src/language/folding.ts
new file mode 100644
index 00000000..5d51f796
--- /dev/null
+++ b/subprojects/frontend/src/language/folding.ts
@@ -0,0 +1,115 @@
+import { EditorState } from '@codemirror/state';
+import type { SyntaxNode } from '@lezer/common';
+
+export type FoldRange = { from: number, to: number };
+
+/**
+ * Folds a block comment between its delimiters.
+ *
+ * @param node the node to fold
+ * @returns the folding range or `null` is there is nothing to fold
+ */
+export function foldBlockComment(node: SyntaxNode): FoldRange {
+  return {
+    from: node.from + 2,
+    to: node.to - 2,
+  };
+}
+
+/**
+ * Folds a declaration after the first element if it appears on the opening line,
+ * otherwise folds after the opening keyword.
+ *
+ * @example
+ * First element on the opening line:
+ * ```
+ * scope Family = 1,
+ *       Person += 5..10.
+ * ```
+ * becomes
+ * ```
+ * scope Family = 1,[...].
+ * ```
+ *
+ * @example
+ * First element not on the opening line:
+ * ```
+ * scope Family
+ *       = 1,
+ *       Person += 5..10.
+ * ```
+ * becomes
+ * ```
+ * scope [...].
+ * ```
+ *
+ * @param node the node to fold
+ * @param state the editor state
+ * @returns the folding range or `null` is there is nothing to fold
+ */
+export function foldDeclaration(node: SyntaxNode, state: EditorState): FoldRange | null {
+  const { firstChild: open, lastChild: close } = node;
+  if (open === null || close === null) {
+    return null;
+  }
+  const { cursor } = open;
+  const lineEnd = state.doc.lineAt(open.from).to;
+  let foldFrom = open.to;
+  while (cursor.next() && cursor.from < lineEnd) {
+    if (cursor.type.name === ',') {
+      foldFrom = cursor.to;
+      break;
+    }
+  }
+  return {
+    from: foldFrom,
+    to: close.from,
+  };
+}
+
+/**
+ * Folds a node only if it has at least one sibling of the same type.
+ *
+ * The folding range will be the entire `node`.
+ *
+ * @param node the node to fold
+ * @returns the folding range or `null` is there is nothing to fold
+ */
+function foldWithSibling(node: SyntaxNode): FoldRange | null {
+  const { parent } = node;
+  if (parent === null) {
+    return null;
+  }
+  const { firstChild } = parent;
+  if (firstChild === null) {
+    return null;
+  }
+  const { cursor } = firstChild;
+  let nSiblings = 0;
+  while (cursor.nextSibling()) {
+    if (cursor.type === node.type) {
+      nSiblings += 1;
+    }
+    if (nSiblings >= 2) {
+      return {
+        from: node.from,
+        to: node.to,
+      };
+    }
+  }
+  return null;
+}
+
+export function foldWholeNode(node: SyntaxNode): FoldRange {
+  return {
+    from: node.from,
+    to: node.to,
+  };
+}
+
+export function foldConjunction(node: SyntaxNode): FoldRange | null {
+  if (node.parent?.type?.name === 'PredicateBody') {
+    return foldWithSibling(node);
+  }
+  return foldWholeNode(node);
+}
diff --git a/subprojects/frontend/src/language/indentation.ts b/subprojects/frontend/src/language/indentation.ts
new file mode 100644
index 00000000..6d36ed3b
--- /dev/null
+++ b/subprojects/frontend/src/language/indentation.ts
@@ -0,0 +1,87 @@
+import { TreeIndentContext } from '@codemirror/language';
+
+/**
+ * Finds the `from` of first non-skipped token, if any,
+ * after the opening keyword in the first line of the declaration.
+ *
+ * Based on
+ * https://github.com/codemirror/language/blob/cd7f7e66fa51ddbce96cf9396b1b6127d0ca4c94/src/indent.ts#L246
+ *
+ * @param context the indentation context
+ * @returns the alignment or `null` if there is no token after the opening keyword
+ */
+function findAlignmentAfterOpening(context: TreeIndentContext): number | null {
+  const {
+    node: tree,
+    simulatedBreak,
+  } = context;
+  const openingToken = tree.childAfter(tree.from);
+  if (openingToken === null) {
+    return null;
+  }
+  const openingLine = context.state.doc.lineAt(openingToken.from);
+  const lineEnd = simulatedBreak == null || simulatedBreak <= openingLine.from
+    ? openingLine.to
+    : Math.min(openingLine.to, simulatedBreak);
+  const { cursor } = openingToken;
+  while (cursor.next() && cursor.from < lineEnd) {
+    if (!cursor.type.isSkipped) {
+      return cursor.from;
+    }
+  }
+  return null;
+}
+
+/**
+ * Indents text after declarations by a single unit if it begins on a new line,
+ * otherwise it aligns with the text after the declaration.
+ *
+ * Based on
+ * https://github.com/codemirror/language/blob/cd7f7e66fa51ddbce96cf9396b1b6127d0ca4c94/src/indent.ts#L275
+ *
+ * @example
+ * Result with no hanging indent (indent unit = 2 spaces, units = 1):
+ * ```
+ * scope
+ *   Family = 1,
+ *   Person += 5..10.
+ * ```
+ *
+ * @example
+ * Result with hanging indent:
+ * ```
+ * scope Family = 1,
+ *       Person += 5..10.
+ * ```
+ *
+ * @param context the indentation context
+ * @param units the number of units to indent
+ * @returns the desired indentation level
+ */
+function indentDeclarationStrategy(context: TreeIndentContext, units: number): number {
+  const alignment = findAlignmentAfterOpening(context);
+  if (alignment !== null) {
+    return context.column(alignment);
+  }
+  return context.baseIndent + units * context.unit;
+}
+
+export function indentBlockComment(): number {
+  // Do not indent.
+  return -1;
+}
+
+export function indentDeclaration(context: TreeIndentContext): number {
+  return indentDeclarationStrategy(context, 1);
+}
+
+export function indentPredicateOrRule(context: TreeIndentContext): number {
+  const clauseIndent = indentDeclarationStrategy(context, 1);
+  if (/^\s+[;.]/.exec(context.textAfter) !== null) {
+    return clauseIndent - 2;
+  }
+  if (/^\s+(~>)/.exec(context.textAfter) !== null) {
+    return clauseIndent - 3;
+  }
+  return clauseIndent;
+}
diff --git a/subprojects/frontend/src/language/problem.grammar b/subprojects/frontend/src/language/problem.grammar
new file mode 100644
index 00000000..1ace2872
--- /dev/null
+++ b/subprojects/frontend/src/language/problem.grammar
@@ -0,0 +1,149 @@
+@detectDelim
+
+@external prop implicitCompletion from '../../../../src/language/props.ts'
+
+@top Problem { statement* }
+
+statement {
+  ProblemDeclaration {
+    ckw<"problem"> QualifiedName "."
+  } |
+  ClassDefinition {
+    ckw<"abstract">? ckw<"class"> RelationName
+    (ckw<"extends"> sep<",", RelationName>)?
+    (ClassBody {  "{" ReferenceDeclaration* "}" } | ".")
+  } |
+  EnumDefinition {
+    ckw<"enum"> RelationName
+    (EnumBody { "{" sep<",", IndividualNodeName> "}" } | ".")
+  } |
+  PredicateDefinition {
+    (ckw<"error"> ckw<"pred">? | ckw<"direct">? ckw<"pred">)
+    RelationName ParameterList<Parameter>?
+    PredicateBody { ("<->" sep<OrOp, Conjunction>)?  "." }
+  } |
+  RuleDefinition {
+    ckw<"direct">? ckw<"rule">
+    RuleName ParameterList<Parameter>?
+    RuleBody { ":" sep<OrOp, Conjunction> "~>" sep<OrOp, Action> "." }
+  } |
+  Assertion {
+    kw<"default">? (NotOp | UnknownOp)? RelationName
+    ParameterList<AssertionArgument> (":" LogicValue)? "."
+  } |
+  NodeValueAssertion {
+    IndividualNodeName ":" Constant "."
+  } |
+  IndividualDeclaration {
+    ckw<"indiv"> sep<",", IndividualNodeName> "."
+  } |
+  ScopeDeclaration {
+    kw<"scope"> sep<",", ScopeElement> "."
+  }
+}
+
+ReferenceDeclaration {
+  (kw<"refers"> | kw<"contains">)?
+  RelationName
+  RelationName
+  ( "[" Multiplicity? "]" )?
+  (kw<"opposite"> RelationName)?
+  ";"?
+}
+
+Parameter { RelationName? VariableName }
+
+Conjunction { ("," | Literal)+ }
+
+OrOp { ";" }
+
+Literal { NotOp? Atom (("=" | ":") sep1<"|", LogicValue>)? }
+
+Atom { RelationName "+"? ParameterList<Argument> }
+
+Action { ("," | ActionLiteral)+ }
+
+ActionLiteral {
+   ckw<"new"> VariableName |
+   ckw<"delete"> VariableName |
+   Literal
+}
+
+Argument { VariableName | Constant }
+
+AssertionArgument { NodeName | StarArgument | Constant }
+
+Constant { Real | String }
+
+LogicValue {
+  ckw<"true"> | ckw<"false"> | ckw<"unknown"> | ckw<"error">
+}
+
+ScopeElement { RelationName ("=" | "+=") Multiplicity }
+
+Multiplicity { (IntMult "..")? (IntMult | StarMult)}
+
+RelationName { QualifiedName }
+
+RuleName { QualifiedName }
+
+IndividualNodeName { QualifiedName }
+
+VariableName { QualifiedName }
+
+NodeName { QualifiedName }
+
+QualifiedName[implicitCompletion=true] { identifier ("::" identifier)* }
+
+kw<term> { @specialize[@name={term},implicitCompletion=true]<identifier, term> }
+
+ckw<term> { @extend[@name={term},implicitCompletion=true]<identifier, term> }
+
+ParameterList<content> { "(" sep<",", content> ")" }
+
+sep<separator, content> { sep1<separator, content>? }
+
+sep1<separator, content> { content (separator content)* }
+
+@skip { LineComment | BlockComment | whitespace }
+
+@tokens {
+  whitespace { std.whitespace+ }
+
+  LineComment { ("//" | "%") ![\n]* }
+
+  BlockComment { "/*" blockCommentRest }
+
+  blockCommentRest { ![*] blockCommentRest | "*" blockCommentAfterStar }
+
+  blockCommentAfterStar { "/" | "*" blockCommentAfterStar | ![/*] blockCommentRest }
+
+  @precedence { BlockComment, LineComment }
+
+  identifier { $[A-Za-z_] $[a-zA-Z0-9_]* }
+
+  int { $[0-9]+ }
+
+  IntMult { int }
+
+  StarMult { "*" }
+
+  Real { "-"? (exponential | int ("." (int | exponential))?) }
+
+  exponential { int ("e" | "E") ("+" | "-")? int }
+
+  String {
+    "'" (![\\'\n] | "\\" ![\n] | "\\\n")+ "'" |
+    "\"" (![\\"\n] | "\\" (![\n] | "\n"))* "\""
+  }
+
+  NotOp { "!" }
+
+  UnknownOp { "?" }
+
+  StarArgument { "*" }
+
+  "{" "}" "(" ")" "[" "]" "." ".." "," ":" "<->" "~>"
+}
+
+@detectDelim
diff --git a/subprojects/frontend/src/language/problemLanguageSupport.ts b/subprojects/frontend/src/language/problemLanguageSupport.ts
new file mode 100644
index 00000000..b858ba91
--- /dev/null
+++ b/subprojects/frontend/src/language/problemLanguageSupport.ts
@@ -0,0 +1,92 @@
+import { styleTags, tags as t } from '@codemirror/highlight';
+import {
+  foldInside,
+  foldNodeProp,
+  indentNodeProp,
+  indentUnit,
+  LanguageSupport,
+  LRLanguage,
+} from '@codemirror/language';
+import { LRParser } from '@lezer/lr';
+
+import { parser } from '../../build/generated/sources/lezer/problem';
+import {
+  foldBlockComment,
+  foldConjunction,
+  foldDeclaration,
+  foldWholeNode,
+} from './folding';
+import {
+  indentBlockComment,
+  indentDeclaration,
+  indentPredicateOrRule,
+} from './indentation';
+
+const parserWithMetadata = (parser as LRParser).configure({
+  props: [
+    styleTags({
+      LineComment: t.lineComment,
+      BlockComment: t.blockComment,
+      'problem class enum pred rule indiv scope': t.definitionKeyword,
+      'abstract extends refers contains opposite error direct default': t.modifier,
+      'true false unknown error': t.keyword,
+      'new delete': t.operatorKeyword,
+      NotOp: t.keyword,
+      UnknownOp: t.keyword,
+      OrOp: t.keyword,
+      StarArgument: t.keyword,
+      'IntMult StarMult Real': t.number,
+      StarMult: t.number,
+      String: t.string,
+      'RelationName/QualifiedName': t.typeName,
+      'RuleName/QualifiedName': t.macroName,
+      'IndividualNodeName/QualifiedName': t.atom,
+      'VariableName/QualifiedName': t.variableName,
+      '{ }': t.brace,
+      '( )': t.paren,
+      '[ ]': t.squareBracket,
+      '. .. , :': t.separator,
+      '<-> ~>': t.definitionOperator,
+    }),
+    indentNodeProp.add({
+      ProblemDeclaration: indentDeclaration,
+      UniqueDeclaration: indentDeclaration,
+      ScopeDeclaration: indentDeclaration,
+      PredicateBody: indentPredicateOrRule,
+      RuleBody: indentPredicateOrRule,
+      BlockComment: indentBlockComment,
+    }),
+    foldNodeProp.add({
+      ClassBody: foldInside,
+      EnumBody: foldInside,
+      ParameterList: foldInside,
+      PredicateBody: foldInside,
+      RuleBody: foldInside,
+      Conjunction: foldConjunction,
+      Action: foldWholeNode,
+      UniqueDeclaration: foldDeclaration,
+      ScopeDeclaration: foldDeclaration,
+      BlockComment: foldBlockComment,
+    }),
+  ],
+});
+
+const problemLanguage = LRLanguage.define({
+  parser: parserWithMetadata,
+  languageData: {
+    commentTokens: {
+      block: {
+        open: '/*',
+        close: '*/',
+      },
+      line: '%',
+    },
+    indentOnInput: /^\s*(?:\{|\}|\(|\)|;|\.|~>)$/,
+  },
+});
+
+export function problemLanguageSupport(): LanguageSupport {
+  return new LanguageSupport(problemLanguage, [
+    indentUnit.of('    '),
+  ]);
+}
diff --git a/subprojects/frontend/src/language/props.ts b/subprojects/frontend/src/language/props.ts
new file mode 100644
index 00000000..8e488bf5
--- /dev/null
+++ b/subprojects/frontend/src/language/props.ts
@@ -0,0 +1,7 @@
+import { NodeProp } from '@lezer/common';
+
+export const implicitCompletion = new NodeProp({
+  deserialize(s: string) {
+    return s === 'true';
+  },
+});