plum

git clone https://pyrossh.dev/repos/plum.git

A statically typed, imperative programming language inspired by rust, python

fddcfa8d — Peter John

Add bindings and queries

Files changed (8) hide show

Cargo.toml +5 -5
bindings/node/binding.cc +4 -4
bindings/node/index.js +2 -2
bindings/rust/build.rs +32 -25
bindings/rust/lib.rs +10 -24
queries/highlights.scm +102 -0
queries/locals.scm +15 -0
queries/tags.scm +41 -0

Cargo.toml CHANGED Viewed

@@ -1,10 +1,10 @@
 [package]
-name = "tree-sitter-pine"
+name = "tree-sitter-palm"
-description = "pine grammar for the tree-sitter parsing library"
+description = "palm grammar for the tree-sitter parsing library"
-version = "0.0.1"
+version = "0.1.0"
-keywords = ["incremental", "parsing", "pine"]
+keywords = ["incremental", "parsing", "palm"]
 categories = ["parsing", "text-editors"]
-repository = "https://github.com/tree-sitter/tree-sitter-pine"
+repository = "https://github.com/pyrossh/tree-sitter-palm"
 edition = "2018"
 license = "MIT"

bindings/node/binding.cc CHANGED Viewed

@@ -4,7 +4,7 @@
 using namespace v8;
-extern "C" TSLanguage * tree_sitter_pine();
+extern "C" TSLanguage * tree_sitter_palm();
 namespace {
@@ -17,12 +17,12 @@ void Init(Local<Object> exports, Local<Object> module) {
   Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
   Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
-  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_pine());
+  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_palm());
-  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("pine").ToLocalChecked());
+  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("palm").ToLocalChecked());
   Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
 }
-NODE_MODULE(tree_sitter_pine_binding, Init)
+NODE_MODULE(tree_sitter_palm_binding, Init)
 }  // namespace

bindings/node/index.js CHANGED Viewed

@@ -1,11 +1,11 @@
 try {
-  module.exports = require("../../build/Release/tree_sitter_pine_binding");
+  module.exports = require("../../build/Release/tree_sitter_palm_binding");
 } catch (error1) {
   if (error1.code !== 'MODULE_NOT_FOUND') {
     throw error1;
   }
   try {
-    module.exports = require("../../build/Debug/tree_sitter_pine_binding");
+    module.exports = require("../../build/Debug/tree_sitter_palm_binding");
   } catch (error2) {
     if (error2.code !== 'MODULE_NOT_FOUND') {
       throw error2;

bindings/rust/build.rs CHANGED Viewed

@@ -1,28 +1,35 @@
-use std::path::Path;
-extern crate cc;
 fn main() {
-    let src_dir = Path::new("src");
+  let src_dir = std::path::Path::new("src");
+  let mut c_config = cc::Build::new();
+  c_config.include(&src_dir);
+  c_config
+      .flag_if_supported("-Wno-unused-parameter")
+      .flag_if_supported("-Wno-unused-but-set-variable")
+      .flag_if_supported("-Wno-trigraphs");
+  let parser_path = src_dir.join("parser.c");
+  c_config.file(&parser_path);
+  let scanner_path = src_dir.join("scanner.c");
+  c_config.file(&scanner_path);
+  println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+  c_config.compile("parser");
+  println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
-    let mut c_config = cc::Build::new();
-    c_config.include(&src_dir);
-    c_config
-        .flag_if_supported("-Wno-unused-parameter")
-        .flag_if_supported("-Wno-unused-but-set-variable")
+  // If your language uses an external scanner written in C++,
-        .flag_if_supported("-Wno-trigraphs");
-    let parser_path = src_dir.join("parser.c");
+  // then include this block of code:
-    c_config.file(&parser_path);
-    println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
-    c_config.compile("parser");
+  /*
-    let mut cpp_config = cc::Build::new();
+  let mut cpp_config = cc::Build::new();
-    cpp_config.cpp(true);
+  cpp_config.cpp(true);
-    cpp_config.include(&src_dir);
+  cpp_config.include(&src_dir);
-    cpp_config
+  cpp_config
-        .flag_if_supported("-Wno-unused-parameter")
+      .flag_if_supported("-Wno-unused-parameter")
-        .flag_if_supported("-Wno-unused-but-set-variable");
+      .flag_if_supported("-Wno-unused-but-set-variable");
-    let scanner_path = src_dir.join("scanner.cc");
+  let scanner_path = src_dir.join("scanner.cc");
-    cpp_config.file(&scanner_path);
+  cpp_config.file(&scanner_path);
+  cpp_config.compile("scanner");
-    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+  println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
-    cpp_config.compile("scanner");
+  */
-}
+}

bindings/rust/lib.rs CHANGED Viewed

@@ -1,27 +1,13 @@
-// -*- coding: utf-8 -*-
-// ------------------------------------------------------------------------------------------------
-// Copyright © 2020, tree-sitter-python authors.
-// See the LICENSE file in this repo for license details.
-// ------------------------------------------------------------------------------------------------
-//! This crate provides a Python grammar for the [tree-sitter][] parsing library.
+//! This crate provides palm language support for the [tree-sitter][] parsing library.
 //!
-//! Typically, you will use the [language][language func] function to add this grammar to a
+//! Typically, you will use the [language][language func] function to add this language to a
 //! tree-sitter [Parser][], and then use the parser to parse some code:
 //!
 //! ```
-//! use tree_sitter::Parser;
-//!
-//! let code = r#"
+//! let code = "";
-//!     def double(x):
-//!         return x * 2
-//! "#;
-//! let mut parser = Parser::new();
+//! let mut parser = tree_sitter::Parser::new();
-//! parser.set_language(tree_sitter_python::language()).expect("Error loading Python grammar");
+//! parser.set_language(tree_sitter_palm::language()).expect("Error loading palm grammar");
-//! let parsed = parser.parse(code, None);
+//! let tree = parser.parse(code, None).unwrap();
-//! # let parsed = parsed.unwrap();
-//! # let root = parsed.root_node();
-//! # assert!(!root.has_error());
 //! ```
 //!
 //! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
@@ -32,17 +18,17 @@
 use tree_sitter::Language;
 extern "C" {
-    fn tree_sitter_python() -> Language;
+    fn tree_sitter_palm() -> Language;
 }
 /// Returns the tree-sitter [Language][] for this grammar.
 ///
 /// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
 pub fn language() -> Language {
-    unsafe { tree_sitter_python() }
+    unsafe { tree_sitter_palm() }
 }
-/// The source of the Python tree-sitter grammar description.
+/// The source of the palm tree-sitter grammar description.
 pub const GRAMMAR: &'static str = include_str!("../../grammar.js");
 /// The syntax highlighting query for this language.
@@ -63,6 +49,6 @@ mod tests {
         let mut parser = tree_sitter::Parser::new();
         parser
             .set_language(super::language())
-            .expect("Error loading Python grammar");
+            .expect("Error loading palm grammar");
     }
 }

queries/highlights.scm ADDED Viewed

@@ -0,0 +1,102 @@
+; Comments
+(module_comment) @comment
+(statement_comment) @comment
+(comment) @comment
+; Constants
+(constant
+  name: (identifier) @constant)
+; Modules
+(module) @module
+(import alias: (identifier) @module)
+(remote_type_identifier
+  module: (identifier) @module)
+(remote_constructor_name
+  module: (identifier) @module)
+((field_access
+  record: (identifier) @module
+  field: (label) @function)
+ (#is-not? local))
+; Functions
+(unqualified_import (identifier) @function)
+(function
+  name: (identifier) @function)
+(external_function
+  name: (identifier) @function)
+(function_parameter
+  name: (identifier) @variable.parameter)
+((function_call
+   function: (identifier) @function)
+ (#is-not? local))
+((binary_expression
+   operator: "|>"
+   right: (identifier) @function)
+ (#is-not? local))
+; "Properties"
+; Assumed to be intended to refer to a name for a field; something that comes
+; before ":" or after "."
+; e.g. record field names, tuple indices, names for named arguments, etc
+(label) @property
+(tuple_access
+  index: (integer) @property)
+; Type names
+(remote_type_identifier) @type
+(type_identifier) @type
+; Data constructors
+(constructor_name) @constructor
+; Literals
+(string) @string
+(bit_string_segment_option) @function.builtin
+(integer) @number
+(float) @number
+; Variables
+(identifier) @variable
+(discard) @comment.unused
+; Operators
+(binary_expression
+  operator: _ @operator)
+"!" @operator
+; Keywords
+[
+  "as"
+  "assert"
+  "case"
+  "const"
+  "extern"
+  "fn"
+  "import"
+  "let"
+  "panic"
+  "todo"
+  "type"
+] @keyword
+; Punctuation
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+[
+  "."
+  ","
+  ":"
+  "#"
+  "="
+  "->"
+  ".."
+  "-"
+  "<-"
+] @punctuation.delimiter

queries/locals.scm ADDED Viewed

@@ -0,0 +1,15 @@
+; Scopes
+(function) @local.scope
+(case_clause) @local.scope
+; Definitions
+(let pattern: (identifier) @local.definition)
+(function_parameter name: (identifier) @local.definition)
+(list_pattern (identifier) @local.definition)
+(list_pattern assign: (identifier) @local.definition)
+(tuple_pattern (identifier) @local.definition)
+(record_pattern_argument pattern: (identifier) @local.definition)
+; References
+(identifier) @local.reference

queries/tags.scm ADDED Viewed

@@ -0,0 +1,41 @@
+; Modules
+(module) @name @reference.module
+(import alias: (identifier) @name) @reference.module
+(remote_type_identifier
+  module: (identifier) @name) @reference.module
+((field_access
+  record: (identifier) @name)
+ (#is-not? local)) @reference.module
+; Functions
+(function
+  name: (identifier) @name) @definition.function
+(external_function
+  name: (identifier) @name) @definition.function
+(unqualified_import (identifier) @name) @reference.function
+((function_call
+   function: (identifier) @name) @reference.function
+ (#is-not? local))
+((field_access
+  record: (identifier) @ignore
+  field: (label) @name)
+ (#is-not? local)) @reference.function
+((binary_expression
+   operator: "|>"
+   right: (identifier) @name)
+ (#is-not? local)) @reference.function
+; Types
+(type_definition
+  (type_name
+    name: (type_identifier) @name)) @definition.type
+(type_definition
+  (data_constructors
+    (data_constructor
+      name: (constructor_name) @name))) @definition.constructor
+(external_type
+  (type_name
+    name: (type_identifier) @name)) @definition.type
+(type_identifier) @name @reference.type
+(constructor_name) @name @reference.constructor

~repos /plum

git clone https://pyrossh.dev/repos/plum.git

A statically typed, imperative programming language inspired by rust, python