rapydscript-ng 0.7.23 → 0.8.0

package/tree-sitter/src/tree_sitter/parser.h

@@ -0,0 +1,286 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
+} TSLanguageMetadata;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+// Used to index the field and supertype maps.
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+  void (*log)(const TSLexer *, const char *, ...);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+  uint16_t reserved_word_set_id;
+} TSLexerMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+typedef struct {
+  int32_t start;
+  int32_t end;
+} TSCharacterRange;
+
+struct TSLanguage {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexerMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+  const char *name;
+  const TSSymbol *reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  const TSSymbol *supertype_symbols;
+  const TSMapSlice *supertype_map_slices;
+  const TSSymbol *supertype_map_entries;
+  TSLanguageMetadata metadata;
+};
+
+static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
+  uint32_t index = 0;
+  uint32_t size = len - index;
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = index + half_size;
+    const TSCharacterRange *range = &ranges[mid_index];
+    if (lookahead >= range->start && lookahead <= range->end) {
+      return true;
+    } else if (lookahead > range->end) {
+      index = mid_index;
+    }
+    size -= half_size;
+  }
+  const TSCharacterRange *range = &ranges[index];
+  return (lookahead >= range->start && lookahead <= range->end);
+}
+
+/*
+ *  Lexer Macros
+ */
+
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define ADVANCE_MAP(...)                                              \
+  {                                                                   \
+    static const uint16_t map[] = { __VA_ARGS__ };                    \
+    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
+      if (map[i] == lookahead) {                                      \
+        state = map[i + 1];                                           \
+        goto next_state;                                              \
+      }                                                               \
+    }                                                                 \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_name, children, precedence, prod_id) \
+  {{                                                       \
+    .reduce = {                                            \
+      .type = TSParseActionTypeReduce,                     \
+      .symbol = symbol_name,                               \
+      .child_count = children,                             \
+      .dynamic_precedence = precedence,                    \
+      .production_id = prod_id                             \
+    },                                                     \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_

package/tree-sitter/test/corpus/chaining.txt

@@ -0,0 +1,99 @@
+==================
+leading dot method chaining
+==================
+
+$(element)
+.css('color', 'red')
+.show()
+
+---
+
+(module
+  (call
+    function: (attribute
+      object: (call
+        function: (attribute
+          object: (call
+            function: (identifier)
+            arguments: (argument_list
+              (identifier)))
+          attribute: (identifier))
+        arguments: (argument_list
+          (string)
+          (string)))
+      attribute: (identifier))
+    arguments: (argument_list)))
+
+==================
+backslash continuation chaining
+==================
+
+x = obj\
+    .css("a", "b")\
+    .show()
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (call
+      function: (attribute
+        object: (call
+          function: (attribute
+            object: (identifier)
+            attribute: (identifier))
+          arguments: (argument_list
+            (string)
+            (string)))
+        attribute: (identifier))
+      arguments: (argument_list))))
+
+==================
+self executing function
+==================
+
+(def(args):
+    log(args)
+)(x)
+
+---
+
+(module
+  (call
+    function: (parenthesized_expression
+      (anonymous_function
+        parameters: (parameters
+          (identifier))
+        body: (block
+          (call
+            function: (identifier)
+            arguments: (argument_list
+              (identifier))))))
+    arguments: (argument_list
+      (identifier))))
+
+==================
+self executing with call
+==================
+
+def():
+    setup()
+.call(this)
+
+---
+
+(module
+  (call
+    function: (attribute
+      object: (anonymous_function
+        parameters: (parameters)
+        body: (block
+          (call
+            function: (identifier)
+            arguments: (argument_list))))
+      attribute: (identifier))
+    arguments: (argument_list
+      (this))))
+

package/tree-sitter/test/corpus/classes.txt

@@ -0,0 +1,147 @@
+==================
+simple class
+==================
+
+class ColorfulTextField:
+    def __init__(self):
+        self.widget = field
+
+---
+
+(module
+  (class_definition
+    name: (identifier)
+    body: (block
+      (function_definition
+        name: (identifier)
+        parameters: (parameters
+          (identifier))
+        body: (block
+          (assignment
+            left: (pattern
+              (attribute
+                object: (identifier)
+                attribute: (identifier)))
+            right: (identifier)))))))
+
+==================
+class with inheritance
+==================
+
+class Child(Parent):
+    def __init__(self):
+        Parent.__init__(self)
+
+---
+
+(module
+  (class_definition
+    name: (identifier)
+    superclasses: (argument_list
+      (identifier))
+    body: (block
+      (function_definition
+        name: (identifier)
+        parameters: (parameters
+          (identifier))
+        body: (block
+          (call
+            function: (attribute
+              object: (identifier)
+              attribute: (identifier))
+            arguments: (argument_list
+              (identifier))))))))
+
+==================
+class multiple inheritance
+==================
+
+class C(A, B):
+    pass
+
+---
+
+(module
+  (class_definition
+    name: (identifier)
+    superclasses: (argument_list
+      (identifier)
+      (identifier))
+    body: (block
+      (pass_statement))))
+
+==================
+static method
+==================
+
+class Test:
+    @staticmethod
+    def staticMethod(a):
+        return a + 1
+
+---
+
+(module
+  (class_definition
+    name: (identifier)
+    body: (block
+      (decorated_definition
+        (decorator
+          (identifier))
+        definition: (function_definition
+          name: (identifier)
+          parameters: (parameters
+            (identifier))
+          body: (block
+            (return_statement
+              (binary_operator
+                left: (identifier)
+                right: (number)))))))))
+
+==================
+external class decorator
+==================
+
+@external
+class Alpha:
+    pass
+
+---
+
+(module
+  (decorated_definition
+    (decorator
+      (identifier))
+    definition: (class_definition
+      name: (identifier)
+      body: (block
+        (pass_statement)))))
+
+==================
+class with scoped flag
+==================
+
+class AutoBound:
+    from __python__ import bound_methods
+
+    def val(self):
+        return self.a
+
+---
+
+(module
+  (class_definition
+    name: (identifier)
+    body: (block
+      (scoped_flag_statement
+        flag: (identifier))
+      (function_definition
+        name: (identifier)
+        parameters: (parameters
+          (identifier))
+        body: (block
+          (return_statement
+            (attribute
+              object: (identifier)
+              attribute: (identifier))))))))
+

package/tree-sitter/test/corpus/comprehensions.txt

@@ -0,0 +1,155 @@
+==================
+list comprehension
+==================
+
+a = [i*i for i in range(20)]
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (list_comprehension
+      body: (binary_operator
+        left: (identifier)
+        right: (identifier))
+      (for_in_clause
+        left: (pattern
+          (identifier))
+        right: (call
+          function: (identifier)
+          arguments: (argument_list
+            (number)))))))
+
+==================
+list comprehension with condition
+==================
+
+a = [i*i for i in range(1,20) if i*i%3 == 0]
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (list_comprehension
+      body: (binary_operator
+        left: (identifier)
+        right: (identifier))
+      (for_in_clause
+        left: (pattern
+          (identifier))
+        right: (call
+          function: (identifier)
+          arguments: (argument_list
+            (number)
+            (number))))
+      (if_clause
+        (comparison_operator
+          (binary_operator
+            left: (binary_operator
+              left: (identifier)
+              right: (identifier))
+            right: (number))
+          (number))))))
+
+==================
+set comprehension
+==================
+
+a = {i*i for i in range(1,20)}
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (set_comprehension
+      body: (binary_operator
+        left: (identifier)
+        right: (identifier))
+      (for_in_clause
+        left: (pattern
+          (identifier))
+        right: (call
+          function: (identifier)
+          arguments: (argument_list
+            (number)
+            (number)))))))
+
+==================
+dict comprehension
+==================
+
+a = {x: x+1 for x in range(20) if x > 2}
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (dictionary_comprehension
+      body: (pair
+        key: (identifier)
+        value: (binary_operator
+          left: (identifier)
+          right: (number)))
+      (for_in_clause
+        left: (pattern
+          (identifier))
+        right: (call
+          function: (identifier)
+          arguments: (argument_list
+            (number))))
+      (if_clause
+        (comparison_operator
+          (identifier)
+          (number))))))
+
+==================
+generator expression
+==================
+
+a = (x for x in items)
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (generator_expression
+      body: (identifier)
+      (for_in_clause
+        left: (pattern
+          (identifier))
+        right: (identifier)))))
+
+==================
+comprehension with tuple target
+==================
+
+a = [(x, y) for x, y in pairs]
+
+---
+
+(module
+  (assignment
+    left: (pattern
+      (identifier))
+    right: (list_comprehension
+      body: (tuple
+        (identifier)
+        (identifier))
+      (for_in_clause
+        left: (pattern_list
+          (pattern
+            (identifier))
+          (pattern
+            (identifier)))
+        right: (identifier)))))
+