tree-sitter-syscript 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# Tree Sitter Syscript
+
+source: [`syscript`](https://github.com/IsCoffeeTho/syscript)
+
+```sy
+// main.sy
+
+fn main() {
+	let hello_message: string = "Hello World!";
+	print(hello_message);
+}
+```

package/binding.gyp

@@ -0,0 +1,35 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_syscript_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+      ],
+      "variables": {
+        "has_scanner": "<!(node -p \"fs.existsSync('src/scanner.c')\")"
+      },
+      "conditions": [
+        ["has_scanner=='true'", {
+          "sources+": ["src/scanner.c"],
+        }],
+        ["OS!='win'", {
+          "cflags_c": [
+            "-std=c11",
+          ],
+        }, { # OS == "win"
+          "cflags_c": [
+            "/std:c11",
+            "/utf-8",
+          ],
+        }],
+      ],
+    }
+  ]
+}

package/grammar.js

@@ -0,0 +1,124 @@
+/**
+ * @file Syscript grammar for tree-sitter
+ * @author Aaron Menadue
+ * @license MIT
+ */
+
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+module.exports = grammar({
+	name: "syscript",
+
+	extras: $ => [/\s/, $.comment],
+
+	conflicts: $ => [
+		[$.code_block, $.struct_literal]
+	],
+
+	rules: {
+		source_file: $ => seq(optional($.shebang), repeat(choice($.function, $.declaration, $.structs, $.classes, $.typedef, $.comment))),
+
+		shebang: $ => seq("#!", /.*/),
+
+		comment: $ => choice($.single_line_comment, $.documentation_comment, $.multi_line_comment, $.unclosed_multi_line_comment),
+		single_line_comment: $ => token(seq("//", /.*/)),
+		documentation_comment: $ => prec.left(1, token(seq("/**", /(.*)*(\n.*)*/, "*/"))),
+		multi_line_comment: $ => prec.left(1, token(seq("/*", /(.*)*(\n.*)*/, "*/"))),
+
+		classes: $ =>
+			seq("class", field("name", $.identifier), optional(seq("extends", $.identifier)), "{", field("fields", repeat(choice($.field, $.method))), "}"),
+		structs: $ => seq("struct", field("name", $.identifier), optional(seq("extends", $.identifier)), "{", field("fields", repeat($.field)), "}"),
+
+		field: $ => seq($.identifier, ":", $.type_signature, ";"),
+		property: $ => seq($.identifier, ":", $.value),
+		property_list: $ => seq($.property, repeat(seq(",", $.property))),
+
+		typedef: $ => seq("typedef", $.identifier, "=", $.type_signature, ";"),
+
+		function: $ => seq("fn", $.method),
+		method: $ => seq(field("name", $.identifier), $.param_list, optional(seq(":", choice($.type_signature, "noreturn"))), $.code_block),
+		param_list: $ => seq("(", optional(seq($.parameter, optional(seq(",", $.parameter)))), ")"),
+		parameter: $ => seq(optional("..."), $.identifier, ":", $.type_signature),
+		code_block: $ => seq("{", repeat($.statement), "}"),
+
+		declaration: $ => seq(choice($.let_declaration, $.const_declaration), ";"),
+		let_declaration: $ => seq("let", field("name", $.identifier), ":", field("type", $.type_signature), optional(seq("=", field("value", $.value)))),
+		const_declaration: $ => seq("const", field("name", $.identifier), ":", field("type", $.type_signature), "=", field("value", $.value)),
+
+		statement: $ => choice($.if_statement, $.while_loop, $.for_loop, $.declaration, seq(choice($.return_statement, $.control_flow, $.value), ";")),
+
+		return_statement: $ => seq("return", optional($.value)),
+		control_flow: $ => choice("break", "continue"),
+
+		routine: $ => choice($.code_block, $.statement),
+		if_statement: $ => prec.right(1, seq("if", field("condition", $.parenthesis_enclosed), $.routine, optional(seq("else", $.routine)))),
+		while_loop: $ => seq("while", field("condition", $.parenthesis_enclosed), $.routine),
+
+		for_loop: $ => seq("for", $.for_loop_def, $.routine),
+		for_loop_def: $ =>
+			seq(
+				"(",
+				field("declaration", optional($.let_declaration)),
+				";",
+				field("condition", optional($.value)),
+				";",
+				field("mutation", optional($.value)),
+				")",
+			),
+
+		value: $ => prec.left(1, seq($.singleton, repeat(seq($.operator, $.singleton)))),
+		value_list: $ => seq($.value, repeat(seq(",", $.value))),
+		parenthesis_enclosed: $ => seq("(", $.value, ")"),
+
+		singleton: $ =>
+			prec.left(
+				1,
+				seq(
+					optional($.type_cast),
+					optional(choice("++", "--", "new", repeat1(choice("!", "-", "~")))),
+					choice($.ref_parenthesis_enclosed, $.ref_primitive, $.reference),
+					optional(choice("++", "--")),
+				),
+			),
+
+		reference: $ => prec.left(1, seq($.identifier, repeat(choice($.accessor, $.func_call)), optional($.sub_reference))),
+		ref_parenthesis_enclosed: $ => prec.left(1, seq($.parenthesis_enclosed, repeat(choice($.accessor, $.func_call)), optional($.sub_reference))),
+		ref_primitive: $ => prec.left(1, seq($.primitive, repeat(choice($.accessor, $.func_call)), optional($.sub_reference))),
+
+		accessor: $ => seq("[", $.value, "]"),
+		func_call: $ => seq("(", optional($.value_list), ")"),
+
+		sub_reference: $ => seq(".", $.reference),
+
+		primitive: $ => choice($.struct_literal, $.array_literal, $.boolean_literal, $.char_literal, $.number_literal, $.string_literal, $.builtin_literal),
+		builtin_literal: $ => choice("this", "super", "null"),
+		array_literal: $ => seq("[", optional($.value_list), "]"),
+		struct_literal: $ => seq("{", optional($.property_list), "}"),
+		boolean_literal: $ => choice("true", "false"),
+		number_literal: $ => choice($.numeric, $.decimal_number, $.hex_number, $.binary_number),
+
+		string_literal: $ => seq('"', repeat(choice(/[^"\\\r\n]+/, $.escaped_character)), '"'),
+
+		char_literal: $ => seq("'", repeat(choice(/[^'\\\r\n]+/, $.escaped_character)), "'"),
+
+		escaped_character: $ => token(seq("\\", choice(/\r?\n/, /[^xuU0-7]/, /[0-7]{1,3}/, /x[0-9a-fA-F]{2}/, /u[0-9a-fA-F]{4}/, /U[0-9a-fA-F]{8}/))),
+
+		decimal_number: $ => prec.left(1, seq($.numeric, ".", $.numeric)),
+		hex_number: $ => /0x[0-9a-fA-F]*/,
+		binary_number: $ => /0b[01]*/,
+
+		type_signature: $ => choice(seq($.identifier, optional("[]")), "void"),
+		type_cast: $ => seq("<", $.type_signature, ">"),
+
+		operator: $ => choice($.logical_op, $.comparative_op, $.arithmetic_op, $.assignment_op),
+
+		logical_op: $ => choice("||", "&&"),
+		comparative_op: $ => choice("==", "!=", ">=", "<=", ">", "<"),
+		arithmetic_op: $ => choice("+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>"),
+		assignment_op: $ => choice("=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^="),
+
+		identifier: $ => /([a-zA-Z_][0-9a-zA-Z_]*)/,
+		numeric: $ => /([0-9][0-9_]*)/,
+	},
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "tree-sitter-syscript",
+	"version": "0.1.0",
+	"description": "Syscript grammar for tree-sitter",
+	"repository": "https://github.com/tree-sitter/tree-sitter-syscript",
+	"license": "MIT",
+	"author": {
+		"name": "Aaron Menadue"
+	},
+	"main": "bindings/node",
+	"types": "bindings/node",
+	"keywords": [
+		"incremental",
+		"parsing",
+		"tree-sitter",
+		"syscript"
+	],
+	"files": [
+		"grammar.js",
+		"tree-sitter.json",
+		"binding.gyp",
+		"prebuilds/**",
+		"bindings/node/*",
+		"queries/*",
+		"src/**",
+		"*.wasm"
+	],
+	"dependencies": {
+		"node-addon-api": "^8.5.0",
+		"node-gyp-build": "^4.8.4",
+		"tree-sitter-syscript": "."
+	},
+	"devDependencies": {
+		"prebuildify": "^6.0.1",
+		"tree-sitter": "^0.22.4",
+		"tree-sitter-cli": "^0.25.10"
+	},
+	"peerDependencies": {
+		"tree-sitter": "^0.22.4"
+	},
+	"peerDependenciesMeta": {
+		"tree-sitter": {
+			"optional": true
+		}
+	},
+	"scripts": {
+		"install": "node-gyp-build",
+		"prestart": "tree-sitter build --wasm",
+		"start": "tree-sitter playground",
+		"test": "node --test bindings/node/*_test.js"
+	}
+}

package/queries/brackets.scm

@@ -0,0 +1,3 @@
+("[" @open "]" @close)
+("{" @open "}" @close)
+("(" @open ")" @close)

package/queries/highlights.scm

@@ -0,0 +1,92 @@
+[
+	"if"
+	"else"
+	"while"
+	"for"
+	"continue"
+	"break"
+	"let"
+	"const"
+	"fn"
+	"return"
+	"class"
+	"struct"
+	"typedef"
+	"extends"
+	"new"
+] @keyword
+
+[
+	"void"
+	"noreturn"
+	"null"
+	"this"
+	"super"
+] @constant.builtin
+
+[
+	"{"
+	"}"
+	"("
+	")"
+	"["
+	"]"
+] @puncuation.bracket
+
+(type_cast
+	"<" @puncuation.bracket
+	(type_signature)
+	">" @puncuation.bracket)
+
+(identifier) @variable
+
+(comment) @comment
+(documentation_comment) @comment.doc
+
+(const_declaration
+	(identifier) @constant)
+
+(shebang) @comment
+
+(boolean_literal) @boolean
+(number_literal) @number
+[
+	(char_literal)
+	(string_literal)
+] @string
+
+(escaped_character) @string.escape
+
+(method
+	(identifier) @function)
+(reference
+	(identifier) @function
+	(func_call))
+(reference
+	(identifier) @variable
+	(accessor)
+	(func_call))
+(singleton
+	"new"
+	(reference
+		(identifier) @type))
+
+(operator) @operator
+
+(let_declaration (identifier) @variable)
+(const_declaration (identifier) @constant)
+
+(field
+	(identifier) @property)
+(property
+	(identifier) @property)
+
+(structs
+	(identifier) @type)
+(classes
+	(identifier) @type)
+
+(type_signature) @type
+(type_signature (identifier) @type) @type
+
+

package/queries/indents.scm

@@ -0,0 +1,2 @@
+(array_literal "]" @end) @indent
+(code_block "}" @end) @indent

package/queries/locals.scm

@@ -0,0 +1,10 @@
+(method) @local.scope
+(for_loop) @local.scope
+(while_loop) @local.scope
+
+(parameter (identifier) @local.definition)
+
+(let_declaration (identifier) @local.definition)
+(const_declaration (identifier) @local.definition)
+
+(singleton (reference (identifier) @local.reference))

package/queries/outlines.scm

@@ -0,0 +1,3 @@
+(method (identifier) @name) @item
+(structs name: (identifier) @name) @item
+(classes name: (identifier) @name) @item

package/queries/tags.scm

@@ -0,0 +1,16 @@
+
+(method
+	name: (identifier) @name) @definition.function
+(classes
+	name: (identifier) @name) @definition.class
+(structs
+	name: (identifier) @name) @definition.interface
+
+(reference
+	((identifier) @name
+		(#is? function))) @reference.call
+
+(singleton
+	"new"
+	(reference
+		(identifier) @name)) @reference.implementation