@algosail/parser 0.0.1

package/lib/types.js

@@ -0,0 +1,148 @@
+import { field, children, childrenOfField } from './utils.js'
+import {
+  moduleGroupRef,
+  groupRef,
+  mapRef,
+  moduleMapRef,
+  effectAdd,
+  effectRemove,
+} from './tokens.js'
+
+export function litType(node) {
+  return {
+    kind: 'lit',
+    name: node.text,
+  }
+}
+
+export function varType(node) {
+  return {
+    kind: 'var',
+    name: node.text,
+  }
+}
+
+export function spreadType(node) {
+  return {
+    kind: 'spread',
+    name: node.text,
+  }
+}
+
+export function mapType(node) {
+  return {
+    kind: 'map',
+    map: mapRef(node),
+  }
+}
+
+export function moduleMapType(node) {
+  return {
+    kind: 'map',
+    ...(moduleMapRef(node) || {}),
+  }
+}
+
+export function groupType(node) {
+  const parseGroup = (node) => {
+    const groupField = field(node, 'group')
+
+    if (groupField.type === 'module_group_ref') {
+      return moduleGroupRef(groupField)
+    }
+
+    return { group: groupRef(groupField) }
+  }
+
+  const parseParam = (node) => {
+    switch (node.type) {
+      case 'group_type':
+        return groupType(node)
+      case 'map_ref':
+        return mapType(node)
+      case 'module_map_ref':
+        return moduleMapType(node)
+      default:
+        return litType(node)
+    }
+  }
+
+  const group = parseGroup(node)
+  const params = childrenOfField(node, 'params').map(parseParam)
+
+  return { kind: 'group', ...group, params }
+}
+
+export function effectAddType(node) {
+  return {
+    kind: 'effect_add',
+    effect: effectAdd(node),
+  }
+}
+
+export function effectRemoveType(node) {
+  return {
+    kind: 'effect_remove',
+    effect: effectRemove(node),
+  }
+}
+
+export function listType(node) {
+  return {
+    kind: 'quotation',
+    inputs: [],
+    outputs: children(node).map(sigItemType),
+    addEffects: [],
+    removeEffects: [],
+  }
+}
+
+export function sigItemType(node) {
+  switch (node.type) {
+    case 'effect_add':
+      return effectAddType(node)
+    case 'effect_remove':
+      return effectRemoveType(node)
+    case 'sig_list':
+      return listType(node)
+    case 'sig_quotation':
+      return sigType(node)
+    case 'group_type':
+      return groupType(node)
+    case 'map_ref':
+      return mapType(node)
+    case 'module_map_ref':
+      return moduleMapType(node)
+    case 'spread':
+      return spreadType(node)
+    case 'type_var':
+      return varType(node)
+    default:
+      return litType(node)
+  }
+}
+
+export function sigType(node) {
+  if (!node) return null
+
+  const items = children(node)
+
+  const arrowIdx = items.findIndex((item) => item.type === 'sig_arrow')
+
+  const inputsNode = arrowIdx >= 0 ? items.slice(0, arrowIdx) : items
+  const outputsNode = arrowIdx >= 0 ? items.slice(arrowIdx + 1) : []
+
+  const isEffect = (n) => n.type === 'effect_add' || n.type === 'effect_remove'
+  const isNoteEffect = (n) => !isEffect(n)
+
+  const isAddEffect = (n) => n.type === 'effect_add'
+  const isRemoveEffect = (n) => n.type === 'effect_remove'
+
+  return {
+    kind: 'quotation',
+    inputs: inputsNode.filter(isNoteEffect).map(sigItemType),
+    outputs: outputsNode.filter(isNoteEffect).map(sigItemType),
+    addEffects: outputsNode.filter(isAddEffect).map(effectAddType),
+    removeEffects: outputsNode.filter(isRemoveEffect).map(effectRemoveType),
+  }
+}

package/lib/utils.js

@@ -0,0 +1,16 @@
+export const capture = (captures, name) => captures.find((c) => c.name === name)?.node ?? null
+
+export const field = (node, name) => {
+  if (Array.isArray(name)) {
+    return name.reduce((res, n) => (res && res.childForFieldName(n)) ?? null, node)
+  }
+  return node.childForFieldName(name) ?? null
+}
+
+export const fieldText = (node, name) => field(node, name)?.text ?? null
+
+export const children = (node) => node.namedChildren
+export const childrenOfType = (node, type) => node.namedChildren.filter((c) => c.type === type)
+export const childrenOfField = (node, field) => node.childrenForFieldName(field)
+
+export const firstOfType = (node, type) => node.namedChildren.find((c) => c.type === type) ?? null

package/lib/word.js

@@ -0,0 +1,141 @@
+import { Query } from 'web-tree-sitter'
+import { capture, field, childrenOfField, children } from './utils.js'
+import {
+  wordDef,
+  wordRef,
+  moduleWordRef,
+  tagRef,
+  moduleTagRef,
+  tagPattern,
+  moduleTagPattern,
+  fieldRef,
+  moduleFieldRef,
+  comment,
+  slotWrite,
+  slotRead,
+  rawString,
+  rawValue,
+} from './tokens.js'
+import { sigType } from './types.js'
+
+export function getWordNodes(rootNode, language) {
+  const query = new Query(language, `(word) @word`)
+  const matches = query.matches(rootNode)
+  const words = matches
+    .map((match) => capture(match.captures, 'word'))
+    .filter(Boolean)
+    .map(parseWord)
+
+  return { words }
+}
+
+function parseWord(node) {
+  const name = wordDef(field(node, 'name_def'))
+  const signature = sigType(field(node, 'sig'))
+  const body = childrenOfField(node, 'body').map(step).filter(Boolean)
+
+  return {
+    name,
+    doc: comment(field(node, 'doc')),
+    signature,
+    body,
+  }
+}
+
+function step(node) {
+  switch (node.type) {
+    case 'quotation':
+      return quotation(node)
+    case 'builtin_word':
+      return builtinWord(node)
+    case 'word_ref':
+      return word(node)
+    case 'module_word_ref':
+      return moduleWord(node)
+    case 'tag_ref':
+      return tagConstructor(node)
+    case 'module_tag_ref':
+      return moduleTagConstructor(node)
+    case 'tag_pattern':
+      return patternTag(node)
+    case 'module_tag_pattern':
+      return patternModuleTag(node)
+    case 'default_pattern':
+      return patternDefault(node)
+    case 'field_ref':
+      return fieldLens(node)
+    case 'module_field_ref':
+      return moduleFieldLens(node)
+    case 'slot_write':
+      return writeSlot(node)
+    case 'slot_read':
+      return readSlot(node)
+    case 'raw_string':
+      return rawFromString(node)
+    case 'raw_value':
+      return raw(node)
+    default:
+      return null
+  }
+}
+
+function quotation(node) {
+  const body = children(node).map(step).filter(Boolean)
+  return { type: 'quotation', body }
+}
+
+function builtinWord(node) {
+  return { type: 'builtin_word', word: node.text }
+}
+
+function word(node) {
+  return { type: 'word', word: wordRef(node) }
+}
+
+function moduleWord(node) {
+  return { type: 'word', ...(moduleWordRef(node) || {}) }
+}
+
+function tagConstructor(node) {
+  return { type: 'tag', tag: tagRef(node) }
+}
+
+function moduleTagConstructor(node) {
+  return { type: 'tag', ...(moduleTagRef(node) || {}) }
+}
+
+function patternTag(node) {
+  return { type: 'pattern_tag', tag: tagPattern(node) }
+}
+
+function patternModuleTag(node) {
+  return { type: 'pattern_tag', ...(moduleTagPattern(node) || {}) }
+}
+
+function patternDefault(_node) {
+  return { type: 'pattern_default' }
+}
+
+function fieldLens(node) {
+  return { type: 'field_lens', field: fieldRef(node) }
+}
+
+function moduleFieldLens(node) {
+  return { type: 'field_lens', ...(moduleFieldRef(node) || {}) }
+}
+
+function writeSlot(node) {
+  return { type: 'slot_write', value: slotWrite(node) }
+}
+
+function readSlot(node) {
+  return { type: 'slot_read', value: slotRead(node) }
+}
+
+function rawFromString(node) {
+  return { type: 'raw', value: rawString(node) }
+}
+
+function raw(node) {
+  return { type: 'raw', value: rawValue(node) }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@algosail/parser",
+  "version": "0.0.1",
+  "description": "Parser for Sail language.",
+  "license": "MIT",
+  "author": "algosail",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@algosail/tree-sitter": "^0.1.6",
+    "tree-sitter-javascript": "^0.25.0",
+    "web-tree-sitter": "^0.26.7"
+  },
+  "devDependencies": {
+    "brittle": "^3.19.1"
+  }
+}