[arch-commits] Commit in bash-language-server/repos (4 files)

Felix Yan felixonmars at archlinux.org
Sat Aug 24 06:12:05 UTC 2019


    Date: Saturday, August 24, 2019 @ 06:12:05
  Author: felixonmars
Revision: 501444

archrelease: copy trunk to community-testing-x86_64

Added:
  bash-language-server/repos/community-testing-x86_64/
  bash-language-server/repos/community-testing-x86_64/0001-node-tree-sitter-nodejs-12-update.patch
    (from rev 501443, bash-language-server/trunk/0001-node-tree-sitter-nodejs-12-update.patch)
  bash-language-server/repos/community-testing-x86_64/PKGBUILD
    (from rev 501443, bash-language-server/trunk/PKGBUILD)
  bash-language-server/repos/community-testing-x86_64/bash-language-server-nodejs-12-update.patch
    (from rev 501443, bash-language-server/trunk/bash-language-server-nodejs-12-update.patch)

----------------------------------------------+
 0001-node-tree-sitter-nodejs-12-update.patch |  744 +++++++++++++++++++++++++
 PKGBUILD                                     |   49 +
 bash-language-server-nodejs-12-update.patch  |   15 
 3 files changed, 808 insertions(+)

Copied: bash-language-server/repos/community-testing-x86_64/0001-node-tree-sitter-nodejs-12-update.patch (from rev 501443, bash-language-server/trunk/0001-node-tree-sitter-nodejs-12-update.patch)
===================================================================
--- community-testing-x86_64/0001-node-tree-sitter-nodejs-12-update.patch	                        (rev 0)
+++ community-testing-x86_64/0001-node-tree-sitter-nodejs-12-update.patch	2019-08-24 06:12:05 UTC (rev 501444)
@@ -0,0 +1,744 @@
+From c526efc6500a1c35d71aee9ce170190b06a7210f Mon Sep 17 00:00:00 2001
+From: "Xl.W" <shawlix+git at gmail.com>
+Date: Thu, 22 Aug 2019 13:33:30 +0800
+Subject: [PATCH] node-tree-sitter: nodejs 12 update
+
+---
+ src/conversions.cc  | 69 +++++++++++++++++++++-------------
+ src/language.cc     |  4 +-
+ src/logger.cc       | 10 ++---
+ src/node.cc         | 75 +++++++++++++++++++++----------------
+ src/parser.cc       | 91 ++++++++++++++++++++++++++-------------------
+ src/tree.cc         | 37 ++++++++++++------
+ src/tree_cursor.cc  | 14 ++++---
+ test/node_test.js   |  2 +-
+ test/parser_test.js |  2 +-
+ 9 files changed, 180 insertions(+), 124 deletions(-)
+
+diff --git a/src/conversions.cc b/src/conversions.cc
+index d024b4c..6d685cd 100644
+--- a/src/conversions.cc
++++ b/src/conversions.cc
+@@ -29,7 +29,7 @@ void InitConversions(Local<Object> exports) {
+ 
+   point_transfer_buffer = static_cast<uint32_t *>(malloc(2 * sizeof(uint32_t)));
+   auto js_point_transfer_buffer = ArrayBuffer::New(Isolate::GetCurrent(), point_transfer_buffer, 2 * sizeof(uint32_t));
+-  exports->Set(Nan::New("pointTransferArray").ToLocalChecked(), Uint32Array::New(js_point_transfer_buffer, 0, 2));
++  Nan::Set(exports, Nan::New("pointTransferArray").ToLocalChecked(), Uint32Array::New(js_point_transfer_buffer, 0, 2));
+ }
+ 
+ void TransferPoint(const TSPoint &point) {
+@@ -39,10 +39,10 @@ void TransferPoint(const TSPoint &point) {
+ 
+ Local<Object> RangeToJS(const TSRange &range) {
+   Local<Object> result = Nan::New<Object>();
+-  result->Set(Nan::New(start_position_key), PointToJS(range.start_point));
+-  result->Set(Nan::New(start_index_key), ByteCountToJS(range.start_byte));
+-  result->Set(Nan::New(end_position_key), PointToJS(range.end_point));
+-  result->Set(Nan::New(end_index_key), ByteCountToJS(range.end_byte));
++  Nan::Set(result, Nan::New(start_position_key), PointToJS(range.start_point));
++  Nan::Set(result, Nan::New(start_index_key), ByteCountToJS(range.start_byte));
++  Nan::Set(result, Nan::New(end_position_key), PointToJS(range.end_point));
++  Nan::Set(result, Nan::New(end_index_key), ByteCountToJS(range.end_byte));
+   return result;
+ }
+ 
+@@ -56,8 +56,13 @@ Nan::Maybe<TSRange> RangeFromJS(const Local<Value> &arg) {
+ 
+   Local<Object> js_range = Local<Object>::Cast(arg);
+ 
+-  #define INIT(field, key, Type) { \
+-    auto field = Type(js_range->Get(Nan::New(key))); \
++  #define INIT(field, key, Convert) { \
++    auto value = Nan::Get(js_range, Nan::New(key)); \
++    if (value.IsEmpty()) { \
++      Nan::ThrowTypeError("Range must be a {startPosition, endPosition, startIndex, endIndex} object"); \
++      return Nan::Nothing<TSRange>(); \
++    } \
++    auto field = Convert(value.ToLocalChecked()); \
+     if (field.IsJust()) { \
+       result.field = field.FromJust(); \
+     } else { \
+@@ -77,41 +82,52 @@ Nan::Maybe<TSRange> RangeFromJS(const Local<Value> &arg) {
+ 
+ Local<Object> PointToJS(const TSPoint &point) {
+   Local<Object> result = Nan::New<Object>();
+-  result->Set(Nan::New(row_key), Nan::New<Number>(point.row));
+-  result->Set(Nan::New(column_key), ByteCountToJS(point.column));
++  Nan::Set(result, Nan::New(row_key), Nan::New<Number>(point.row));
++  Nan::Set(result, Nan::New(column_key), ByteCountToJS(point.column));
+   return result;
+ }
+ 
+ Nan::Maybe<TSPoint> PointFromJS(const Local<Value> &arg) {
+-  if (!arg->IsObject()) {
++  Local<Object> js_point;
++  if (!Nan::To<Object>(arg).ToLocal(&js_point)) {
+     Nan::ThrowTypeError("Point must be a {row, column} object");
+     return Nan::Nothing<TSPoint>();
+   }
+ 
+-  Local<Object> js_point = Local<Object>::Cast(arg);
+-  Local<Value> js_row = js_point->Get(Nan::New(row_key));
+-  if (!js_row->IsNumber()) {
+-    Nan::ThrowTypeError("Point.row must be a number");
++  Local<Value> js_row;
++  if (!Nan::Get(js_point, Nan::New(row_key)).ToLocal(&js_row)) {
++    Nan::ThrowTypeError("Point must be a {row, column} object");
+     return Nan::Nothing<TSPoint>();
+   }
+ 
+-  Local<Value> js_column = js_point->Get(Nan::New(column_key));
+-  if (!js_column->IsNumber()) {
+-    Nan::ThrowTypeError("Point.column must be a number");
++  Local<Value> js_column;
++  if (!Nan::Get(js_point, Nan::New(column_key)).ToLocal(&js_column)) {
++    Nan::ThrowTypeError("Point must be a {row, column} object");
+     return Nan::Nothing<TSPoint>();
+   }
+ 
+-  uint32_t row, column;
+-  if (std::isfinite(js_row->NumberValue())) {
+-    row = static_cast<uint32_t>(js_row->Int32Value());
+-  } else {
++  uint32_t row;
++  if (!std::isfinite(Nan::To<double>(js_row).FromMaybe(0))) {
+     row = UINT32_MAX;
++  } else {
++    auto maybe_row = Nan::To<uint32_t>(js_row);
++    if (!maybe_row.IsJust()) {
++      Nan::ThrowTypeError("Point.row must be a number");
++      return Nan::Nothing<TSPoint>();
++    }
++    row = maybe_row.FromJust();
+   }
+ 
+-  if (std::isfinite(js_column->NumberValue())) {
+-    column = static_cast<uint32_t>(js_column->Int32Value()) * BYTES_PER_CHARACTER;
+-  } else {
++  uint32_t column;
++  if (!std::isfinite(Nan::To<double>(js_column).FromMaybe(0))) {
+     column = UINT32_MAX;
++  } else {
++    auto maybe_column = Nan::To<uint32_t>(js_column);
++    if (!maybe_column.IsJust()) {
++      Nan::ThrowTypeError("Point.column must be a number");
++      return Nan::Nothing<TSPoint>();
++    }
++    column = maybe_column.FromJust();
+   }
+ 
+   return Nan::Just<TSPoint>({row, column});
+@@ -122,12 +138,13 @@ Local<Number> ByteCountToJS(uint32_t byte_count) {
+ }
+ 
+ Nan::Maybe<uint32_t> ByteCountFromJS(const v8::Local<v8::Value> &arg) {
+-  if (!arg->IsUint32()) {
++  auto result = Nan::To<uint32_t>(arg);
++  if (!result.IsJust()) {
+     Nan::ThrowTypeError("Character index must be a number");
+     return Nan::Nothing<uint32_t>();
+   }
+ 
+-  return Nan::Just<uint32_t>(arg->Uint32Value() * BYTES_PER_CHARACTER);
++  return Nan::Just<uint32_t>(result.FromJust() * BYTES_PER_CHARACTER);
+ }
+ 
+ }  // namespace node_tree_sitter
+diff --git a/src/language.cc b/src/language.cc
+index 9a25b02..a804433 100644
+--- a/src/language.cc
++++ b/src/language.cc
+@@ -77,12 +77,12 @@ static void GetNodeFieldNamesById(const Nan::FunctionCallbackInfo<Value> &info)
+ void Init(Local<Object> exports) {
+   exports->Set(
+     Nan::New("getNodeTypeNamesById").ToLocalChecked(),
+-    Nan::New<FunctionTemplate>(GetNodeTypeNamesById)->GetFunction()
++    Nan::GetFunction(Nan::New<FunctionTemplate>(GetNodeTypeNamesById)).ToLocalChecked()
+   );
+ 
+   exports->Set(
+     Nan::New("getNodeFieldNamesById").ToLocalChecked(),
+-    Nan::New<FunctionTemplate>(GetNodeFieldNamesById)->GetFunction()
++    Nan::GetFunction(Nan::New<FunctionTemplate>(GetNodeFieldNamesById)).ToLocalChecked()
+   );
+ }
+ 
+diff --git a/src/logger.cc b/src/logger.cc
+index 00e624e..5f0cacd 100644
+--- a/src/logger.cc
++++ b/src/logger.cc
+@@ -36,21 +36,21 @@ void Logger::Log(void *payload, TSLogType type, const char *message_str) {
+ 
+     string key = message.substr(key_pos, (value_sep_pos - key_pos));
+     string value = message.substr(val_pos, (param_sep_pos - val_pos));
+-    params->Set(Nan::New(key).ToLocalChecked(), Nan::New(value).ToLocalChecked());
++    Nan::Set(params, Nan::New(key).ToLocalChecked(), Nan::New(value).ToLocalChecked());
+   }
+ 
+   Local<Value> argv[3] = { name, params, type_name };
+   TryCatch try_catch(Isolate::GetCurrent());
+-  fn->Call(fn->CreationContext()->Global(), 3, argv);
++  Nan::Call(fn, fn->CreationContext()->Global(), 3, argv);
+   if (try_catch.HasCaught()) {
+     Local<Value> log_argv[2] = {
+       Nan::New("Error in debug callback:").ToLocalChecked(),
+       try_catch.Exception()
+     };
+ 
+-    Local<Object> console = Local<Object>::Cast(fn->CreationContext()->Global()->Get(Nan::New("console").ToLocalChecked()));
+-    Local<Function> error_fn = Local<Function>::Cast(console->Get(Nan::New("error").ToLocalChecked()));
+-    error_fn->Call(console, 2, log_argv);
++    Local<Object> console = Local<Object>::Cast(Nan::Get(fn->CreationContext()->Global(), Nan::New("console").ToLocalChecked()).ToLocalChecked());
++    Local<Function> error_fn = Local<Function>::Cast(Nan::Get(console, Nan::New("error").ToLocalChecked()).ToLocalChecked());
++    Nan::Call(error_fn, console, 2, log_argv);
+   }
+ }
+ 
+diff --git a/src/node.cc b/src/node.cc
+index 8a5517f..5f4ad93 100644
+--- a/src/node.cc
++++ b/src/node.cc
+@@ -27,7 +27,8 @@ static inline void setup_transfer_buffer(uint32_t node_count) {
+     transfer_buffer_length = new_length;
+     transfer_buffer = static_cast<uint32_t *>(malloc(transfer_buffer_length * sizeof(uint32_t)));
+     auto js_transfer_buffer = ArrayBuffer::New(Isolate::GetCurrent(), transfer_buffer, transfer_buffer_length * sizeof(uint32_t));
+-    Nan::New(module_exports)->Set(
++    Nan::Set(
++      Nan::New(module_exports),
+       Nan::New("nodeTransferArray").ToLocalChecked(),
+       Uint32Array::New(js_transfer_buffer, 0, transfer_buffer_length)
+     );
+@@ -56,13 +57,12 @@ static void MarshalNodes(const Nan::FunctionCallbackInfo<Value> &info,
+       *(p++) = node.context[2];
+       *(p++) = node.context[3];
+       if (node.id) {
+-        result->Set(i, Nan::New(ts_node_symbol(node)));
++        Nan::Set(result, i, Nan::New(ts_node_symbol(node)));
+       } else {
+-        result->Set(i, Nan::Null());
++        Nan::Set(result, i, Nan::Null());
+       }
+     } else {
+-      assert(!cache_entry->second->node.IsNearDeath());
+-      result->Set(i, Nan::New(cache_entry->second->node));
++      Nan::Set(result, i, Nan::New(cache_entry->second->node));
+     }
+   }
+   info.GetReturnValue().Set(result);
+@@ -83,7 +83,6 @@ void MarshalNode(const Nan::FunctionCallbackInfo<Value> &info, const Tree *tree,
+       info.GetReturnValue().Set(Nan::New(ts_node_symbol(node)));
+     }
+   } else {
+-    assert(!cache_entry->second->node.IsNearDeath());
+     info.GetReturnValue().Set(Nan::New(cache_entry->second->node));
+   }
+ }
+@@ -317,7 +316,7 @@ static void Child(const Nan::FunctionCallbackInfo<Value> &info) {
+       Nan::ThrowTypeError("Second argument must be an integer");
+       return;
+     }
+-    uint32_t index = info[1]->Uint32Value();
++    uint32_t index = Nan::To<uint32_t>(info[1]).FromJust();
+     MarshalNode(info, tree, ts_node_child(node, index));
+     return;
+   }
+@@ -333,7 +332,7 @@ static void NamedChild(const Nan::FunctionCallbackInfo<Value> &info) {
+       Nan::ThrowTypeError("Second argument must be an integer");
+       return;
+     }
+-    uint32_t index = info[1]->Uint32Value();
++    uint32_t index = Nan::To<uint32_t>(info[1]).FromJust();
+     MarshalNode(info, tree, ts_node_named_child(node, index));
+     return;
+   }
+@@ -470,26 +469,37 @@ bool symbol_set_from_js(SymbolSet *symbols, const Local<Value> &value, const TSL
+ 
+   Local<Array> js_types = Local<Array>::Cast(value);
+   for (unsigned i = 0, n = js_types->Length(); i < n; i++) {
+-    Local<Value> js_types_i = js_types->Get(i);
+-    if (!js_types_i->IsString()) {
+-      Nan::ThrowTypeError("Argument must be a string or array of strings");
+-      return false;
+-    }
+-
+-    Local<String> js_node_type = Local<String>::Cast(js_types_i);
+-    std::string node_type(js_node_type->Utf8Length(), '\0');
+-    js_node_type->WriteUtf8(&node_type[0]);
+-
+-    if (node_type == "ERROR") {
+-      symbols->add(static_cast<TSSymbol>(-1));
+-      continue;
+-    }
++    Local<Value> js_node_type_value;
++    if (Nan::Get(js_types, i).ToLocal(&js_node_type_value)) {
++      Local<String> js_node_type;
++      if (Nan::To<String>(js_node_type_value).ToLocal(&js_node_type)) {
++        std::string node_type(js_node_type->Utf8Length(Isolate::GetCurrent()), '\0');
++        js_node_type->WriteUtf8(
++
++          // Nan doesn't wrap this functionality
++          #if NODE_MAJOR_VERSION >= 12
++                Isolate::GetCurrent(),
++          #endif
++
++          &node_type[0]
++        );
++
++        if (node_type == "ERROR") {
++          symbols->add(static_cast<TSSymbol>(-1));
++        } else {
++          for (TSSymbol j = 0; j < symbol_count; j++) {
++            if (node_type == ts_language_symbol_name(language, j)) {
++              symbols->add(j);
++            }
++          }
++        }
+ 
+-    for (TSSymbol j = 0; j < symbol_count; j++) {
+-      if (node_type == ts_language_symbol_name(language, j)) {
+-        symbols->add(j);
++        continue;
+       }
+     }
++
++    Nan::ThrowTypeError("Argument must be a string or array of strings");
++    return false;
+   }
+ 
+   return true;
+@@ -542,13 +552,13 @@ static void DescendantsOfType(const Nan::FunctionCallbackInfo<Value> &info) {
+   TSPoint start_point = {0, 0};
+   TSPoint end_point = {UINT32_MAX, UINT32_MAX};
+ 
+-  if (info[2]->BooleanValue()) {
++  if (info.Length() > 2) {
+     auto maybe_start_point = PointFromJS(info[2]);
+     if (maybe_start_point.IsNothing()) return;
+     start_point = maybe_start_point.FromJust();
+   }
+ 
+-  if (info[3]->BooleanValue()) {
++  if (info.Length() > 3) {
+     auto maybe_end_point = PointFromJS(info[3]);
+     if (maybe_end_point.IsNothing()) return;
+     end_point = maybe_end_point.FromJust();
+@@ -606,7 +616,7 @@ static void ChildNodesForFieldId(const Nan::FunctionCallbackInfo<Value> &info) {
+     Nan::ThrowTypeError("Second argument must be an integer");
+     return;
+   }
+-  uint32_t field_id = info[1]->Uint32Value();
++  uint32_t field_id = Nan::To<uint32_t>(info[1]).FromJust();
+ 
+   vector<TSNode> result;
+   ts_tree_cursor_reset(&scratch_cursor, node);
+@@ -631,7 +641,7 @@ static void ChildNodeForFieldId(const Nan::FunctionCallbackInfo<Value> &info) {
+       Nan::ThrowTypeError("Second argument must be an integer");
+       return;
+     }
+-    uint32_t field_id = info[1]->Uint32Value();
++    uint32_t field_id = Nan::To<uint32_t>(info[1]).FromJust();
+     MarshalNode(info, tree, ts_node_child_by_field_id(node, field_id));
+     return;
+   }
+@@ -710,16 +720,17 @@ void Init(Local<Object> exports) {
+   };
+ 
+   for (size_t i = 0; i < length_of_array(methods); i++) {
+-    result->Set(
++    Nan::Set(
++      result,
+       Nan::New(methods[i].name).ToLocalChecked(),
+-      Nan::New<FunctionTemplate>(methods[i].callback)->GetFunction()
++      Nan::GetFunction(Nan::New<FunctionTemplate>(methods[i].callback)).ToLocalChecked()
+     );
+   }
+ 
+   module_exports.Reset(exports);
+   setup_transfer_buffer(1);
+ 
+-  exports->Set(Nan::New("NodeMethods").ToLocalChecked(), result);
++  Nan::Set(exports, Nan::New("NodeMethods").ToLocalChecked(), result);
+ }
+ 
+ }  // namespace node_methods
+diff --git a/src/parser.cc b/src/parser.cc
+index 7eddd39..420c7b1 100644
+--- a/src/parser.cc
++++ b/src/parser.cc
+@@ -26,11 +26,8 @@ class CallbackInput {
+     : callback(callback),
+       byte_offset(0),
+       partial_string_offset(0) {
+-    if (js_buffer_size->IsUint32()) {
+-      buffer.resize(Local<Integer>::Cast(js_buffer_size)->Uint32Value());
+-    } else {
+-      buffer.resize(32 * 1024);
+-    }
++    uint32_t buffer_size = Nan::To<uint32_t>(js_buffer_size).FromMaybe(32 * 1024);
++    buffer.resize(buffer_size);
+   }
+ 
+   TSInput Input() {
+@@ -51,8 +48,9 @@ class CallbackInput {
+       reader->partial_string.Reset();
+     }
+ 
++    *bytes_read = 0;
+     Local<String> result;
+-    uint32_t start;
++    uint32_t start = 0;
+     if (reader->partial_string_offset) {
+       result = Nan::New(reader->partial_string);
+       start = reader->partial_string_offset;
+@@ -61,18 +59,26 @@ class CallbackInput {
+       uint32_t utf16_unit = byte / 2;
+       Local<Value> argv[2] = { Nan::New<Number>(utf16_unit), PointToJS(position) };
+       TryCatch try_catch(Isolate::GetCurrent());
+-      auto result_value = callback->Call(Nan::Null(), 2, argv);
+-      if (!try_catch.HasCaught() && result_value->IsString()) {
+-        result = Local<String>::Cast(result_value);
+-        start = 0;
+-      } else {
+-        *bytes_read = 0;
+-        start = 0;
+-        return "";
+-      }
++      auto maybe_result_value = Nan::Call(callback, callback->CreationContext()->Global(), 2, argv);
++      if (try_catch.HasCaught()) return nullptr;
++
++      Local<Value> result_value;
++      if (!maybe_result_value.ToLocal(&result_value)) return nullptr;
++      if (!Nan::To<String>(result_value).ToLocal(&result)) return nullptr;
+     }
+ 
+-    int utf16_units_read = result->Write(reader->buffer.data(), start, reader->buffer.size(), 2);
++    int utf16_units_read = result->Write(
++
++      // Nan doesn't wrap this functionality
++      #if NODE_MAJOR_VERSION >= 12
++            Isolate::GetCurrent(),
++      #endif
++
++      reader->buffer.data(),
++      start,
++      reader->buffer.size(),
++      2
++    );
+     int end = start + utf16_units_read;
+     *bytes_read = 2 * utf16_units_read;
+ 
+@@ -173,9 +179,9 @@ void Parser::Init(Local<Object> exports) {
+     Nan::SetPrototypeMethod(tpl, methods[i].name, methods[i].callback);
+   }
+ 
+-  constructor.Reset(Nan::Persistent<Function>(tpl->GetFunction()));
+-  exports->Set(class_name, Nan::New(constructor));
+-  exports->Set(Nan::New("LANGUAGE_VERSION").ToLocalChecked(), Nan::New<Number>(TREE_SITTER_LANGUAGE_VERSION));
++  constructor.Reset(Nan::Persistent<Function>(Nan::GetFunction(tpl).ToLocalChecked()));
++  Nan::Set(exports, class_name, Nan::New(constructor));
++  Nan::Set(exports, Nan::New("LANGUAGE_VERSION").ToLocalChecked(), Nan::New<Number>(TREE_SITTER_LANGUAGE_VERSION));
+ }
+ 
+ Parser::Parser() : parser_(ts_parser_new()), is_parsing_async_(false) {}
+@@ -188,7 +194,9 @@ static bool handle_included_ranges(TSParser *parser, Local<Value> arg) {
+     auto js_included_ranges = Local<Array>::Cast(arg);
+     vector<TSRange> included_ranges;
+     for (unsigned i = 0; i < js_included_ranges->Length(); i++) {
+-      auto maybe_range = RangeFromJS(js_included_ranges->Get(i));
++      Local<Value> range_value;
++      if (!Nan::Get(js_included_ranges, i).ToLocal(&range_value)) return false;
++      auto maybe_range = RangeFromJS(range_value);
+       if (!maybe_range.IsJust()) return false;
+       auto range = maybe_range.FromJust();
+       if (range.start_byte < last_included_range_end) {
+@@ -250,9 +258,10 @@ void Parser::Parse(const Nan::FunctionCallbackInfo<Value> &info) {
+ 
+   Local<Function> callback = Local<Function>::Cast(info[0]);
+ 
++  Local<Object> js_old_tree;
+   const TSTree *old_tree = nullptr;
+-  if (info.Length() > 1 && info[1]->BooleanValue()) {
+-    const Tree *tree = Tree::UnwrapTree(info[1]);
++  if (info.Length() > 1 && Nan::To<Object>(info[1]).ToLocal(&js_old_tree)) {
++    const Tree *tree = Tree::UnwrapTree(js_old_tree);
+     if (!tree) {
+       Nan::ThrowTypeError("Second argument must be a tree");
+       return;
+@@ -305,9 +314,10 @@ void Parser::ParseTextBuffer(const Nan::FunctionCallbackInfo<Value> &info) {
+     return;
+   }
+ 
++  Local<Object> js_old_tree;
+   const TSTree *old_tree = nullptr;
+-  if (info.Length() > 2 && info[2]->BooleanValue()) {
+-    const Tree *tree = Tree::UnwrapTree(info[2]);
++  if (info.Length() > 2 && Nan::To<Object>(info[2]).ToLocal(&js_old_tree)) {
++    const Tree *tree = Tree::UnwrapTree(js_old_tree);
+     if (!tree) {
+       Nan::ThrowTypeError("Second argument must be a tree");
+       return;
+@@ -322,18 +332,21 @@ void Parser::ParseTextBuffer(const Nan::FunctionCallbackInfo<Value> &info) {
+ 
+   // If a `syncTimeoutMicros` option is passed, parse synchronously
+   // for the given amount of time before queuing an async task.
+-  if (info[4]->BooleanValue()) {
+-    double js_sync_timeout = info[4]->NumberValue();
++  double js_sync_timeout = Nan::To<double>(info[4]).FromMaybe(-1);
++  if (js_sync_timeout > 0) {
+     size_t sync_timeout;
+ 
+     // If the timeout is `Infinity`, then parse synchronously with no timeout.
+-    if (js_sync_timeout > 0 && !std::isfinite(js_sync_timeout)) {
++    if (js_sync_timeout && !std::isfinite(js_sync_timeout)) {
+       sync_timeout = 0;
+-    } else if (info[4]->IsUint32()) {
+-      sync_timeout = info[4]->Uint32Value();
+     } else {
+-      Nan::ThrowTypeError("The `syncTimeoutMicros` option must be a positive integer.");
+-      return;
++      auto maybe_sync_timeout = Nan::To<uint32_t>(info[4]);
++      if (maybe_sync_timeout.IsJust()) {
++        sync_timeout = maybe_sync_timeout.FromJust();
++      } else {
++        Nan::ThrowTypeError("The `syncTimeoutMicros` option must be a positive integer.");
++        return;
++      }
+     }
+ 
+     // Logging is disabled for this method, because we can't call the
+@@ -348,7 +361,8 @@ void Parser::ParseTextBuffer(const Nan::FunctionCallbackInfo<Value> &info) {
+     if (result) {
+       delete input;
+       Local<Value> argv[] = {Tree::NewInstance(result)};
+-      info[0].As<Function>()->Call(Nan::Null(), 1, argv);
++      auto callback = info[0].As<Function>();
++      Nan::Call(callback, callback->CreationContext()->Global(), 1, argv);
+       return;
+     }
+   }
+@@ -369,9 +383,10 @@ void Parser::ParseTextBufferSync(const Nan::FunctionCallbackInfo<Value> &info) {
+     return;
+   }
+ 
+-  TSTree *old_tree = nullptr;
+-  if (info.Length() > 1 && info[1]->BooleanValue()) {
+-    const Tree *tree = Tree::UnwrapTree(info[1]);
++  Local<Object> js_old_tree;
++  const TSTree *old_tree = nullptr;
++  if (info.Length() > 1 && Nan::To<Object>(info[1]).ToLocal(&js_old_tree)) {
++    const Tree *tree = Tree::UnwrapTree(js_old_tree);
+     if (!tree) {
+       Nan::ThrowTypeError("Second argument must be a tree");
+       return;
+@@ -411,7 +426,7 @@ void Parser::SetLogger(const Nan::FunctionCallbackInfo<Value> &info) {
+   if (info[0]->IsFunction()) {
+     if (current_logger.payload) delete (Logger *)current_logger.payload;
+     ts_parser_set_logger(parser->parser_, Logger::Make(Local<Function>::Cast(info[0])));
+-  } else if (!info[0]->BooleanValue()) {
++  } else if (!Nan::To<bool>(info[0]).FromMaybe(true)) {
+     if (current_logger.payload) delete (Logger *)current_logger.payload;
+     ts_parser_set_logger(parser->parser_, { 0, 0 });
+   } else {
+@@ -429,9 +444,7 @@ void Parser::PrintDotGraphs(const Nan::FunctionCallbackInfo<Value> &info) {
+     return;
+   }
+ 
+-  Local<Boolean> value = Local<Boolean>::Cast(info[0]);
+-
+-  if (value->IsBoolean() && value->BooleanValue()) {
++  if (Nan::To<bool>(info[0]).FromMaybe(false)) {
+     ts_parser_print_dot_graphs(parser->parser_, 2);
+   } else {
+     ts_parser_print_dot_graphs(parser->parser_, -1);
+diff --git a/src/tree.cc b/src/tree.cc
+index c41437a..2800075 100644
+--- a/src/tree.cc
++++ b/src/tree.cc
+@@ -34,11 +34,11 @@ void Tree::Init(Local<Object> exports) {
+     Nan::SetPrototypeMethod(tpl, methods[i].name, methods[i].callback);
+   }
+ 
+-  Local<Function> ctor = tpl->GetFunction();
++  Local<Function> ctor = Nan::GetFunction(tpl).ToLocalChecked();
+ 
+   constructor_template.Reset(tpl);
+   constructor.Reset(ctor);
+-  exports->Set(class_name, ctor);
++  Nan::Set(exports, class_name, ctor);
+ }
+ 
+ Tree::Tree(TSTree *tree) : tree_(tree) {}
+@@ -53,10 +53,14 @@ Tree::~Tree() {
+ Local<Value> Tree::NewInstance(TSTree *tree) {
+   if (tree) {
+     Local<Object> self;
+-    MaybeLocal<Object> maybe_self = Nan::New(constructor)->NewInstance(Nan::GetCurrentContext());
++    printf("NEW INSTANCE TIME %d\n", Nan::New(constructor)->IsFunction());
++    MaybeLocal<Object> maybe_self = Nan::NewInstance(Nan::New(constructor));
+     if (maybe_self.ToLocal(&self)) {
++      puts("GOT A LOCAL");
+       (new Tree(tree))->Wrap(self);
+       return self;
++    } else {
++      puts("DID NOT GOT A LOCAL");
+     }
+   }
+   return Nan::Null();
+@@ -70,14 +74,17 @@ const Tree *Tree::UnwrapTree(const Local<Value> &value) {
+ }
+ 
+ void Tree::New(const Nan::FunctionCallbackInfo<Value> &info) {
+-  info.GetReturnValue().Set(Nan::Null());
++  printf("IS CONSTRUCT CALL %d\n", info.IsConstructCall());
++  info.GetReturnValue().Set(info.This());
+ }
+ 
+ #define read_number_from_js(out, value, name)        \
+-  if (!(value)->IsUint32()) {                       \
++  maybe_number = Nan::To<uint32_t>(value);           \
++  if (maybe_number.IsNothing()) {                    \
+     Nan::ThrowTypeError(name " must be an integer"); \
++    return;                                          \
+   }                                                  \
+-  *(out) = (value)->Uint32Value()
++  *(out) = maybe_number.FromJust();
+ 
+ #define read_byte_count_from_js(out, value, name)   \
+   read_number_from_js(out, value, name);            \
+@@ -87,6 +94,7 @@ void Tree::Edit(const Nan::FunctionCallbackInfo<Value> &info) {
+   Tree *tree = ObjectWrap::Unwrap<Tree>(info.This());
+ 
+   TSInputEdit edit;
++  Nan::Maybe<uint32_t> maybe_number = Nan::Nothing<uint32_t>();
+   read_number_from_js(&edit.start_point.row, info[0], "startPosition.row");
+   read_byte_count_from_js(&edit.start_point.column, info[1], "startPosition.column");
+   read_number_from_js(&edit.old_end_point.row, info[2], "oldEndPosition.row");
+@@ -104,13 +112,16 @@ void Tree::Edit(const Nan::FunctionCallbackInfo<Value> &info) {
+     TSNode node;
+     node.id = entry.first;
+     for (unsigned i = 0; i < 4; i++) {
+-      node.context[i] = js_node->Get(i + 2)->Uint32Value();
++      Local<Value> node_field;
++      if (Nan::Get(js_node, i + 2).ToLocal(&node_field)) {
++        node.context[i] = Nan::To<uint32_t>(node_field).FromMaybe(0);
++      }
+     }
+ 
+     ts_node_edit(&node, &edit);
+ 
+     for (unsigned i = 0; i < 4; i++) {
+-      js_node->Set(i + 2, Nan::New(node.context[i]));
++      Nan::Set(js_node, i + 2, Nan::New(node.context[i]));
+     }
+   }
+ 
+@@ -135,7 +146,7 @@ void Tree::GetChangedRanges(const Nan::FunctionCallbackInfo<Value> &info) {
+ 
+   Local<Array> result = Nan::New<Array>();
+   for (size_t i = 0; i < range_count; i++) {
+-    result->Set(i, RangeToJS(ranges[i]));
++    Nan::Set(result, i, RangeToJS(ranges[i]));
+   }
+ 
+   info.GetReturnValue().Set(result);
+@@ -197,7 +208,6 @@ void Tree::PrintDotGraph(const Nan::FunctionCallbackInfo<Value> &info) {
+ 
+ static void FinalizeNode(const v8::WeakCallbackInfo<Tree::NodeCacheEntry> &info) {
+   Tree::NodeCacheEntry *cache_entry = info.GetParameter();
+-  assert(cache_entry->node.IsNearDeath());
+   assert(!cache_entry->node.IsEmpty());
+   cache_entry->node.Reset();
+   if (cache_entry->tree) {
+@@ -211,9 +221,12 @@ void Tree::CacheNode(const Nan::FunctionCallbackInfo<Value> &info) {
+   Tree *tree = ObjectWrap::Unwrap<Tree>(info.This());
+   Local<Object> js_node = Local<Object>::Cast(info[0]);
+ 
++  Local<Value> js_node_field1, js_node_field2;
++  if (!Nan::Get(js_node, 0).ToLocal(&js_node_field1)) return;
++  if (!Nan::Get(js_node, 1).ToLocal(&js_node_field2)) return;
+   uint32_t key_parts[2] = {
+-    js_node->Get(0)->Uint32Value(),
+-    js_node->Get(1)->Uint32Value(),
++    Nan::To<uint32_t>(js_node_field1).FromMaybe(0),
++    Nan::To<uint32_t>(js_node_field2).FromMaybe(0)
+   };
+   const void *key = UnmarshalNodeId(key_parts);
+ 
+diff --git a/src/tree_cursor.cc b/src/tree_cursor.cc
+index 332a14b..a1bb741 100644
+--- a/src/tree_cursor.cc
++++ b/src/tree_cursor.cc
+@@ -49,8 +49,8 @@ void TreeCursor::Init(v8::Local<v8::Object> exports) {
+     Nan::SetPrototypeMethod(tpl, methods[i].name, methods[i].callback);
+   }
+ 
+-  Local<Function> constructor_local = tpl->GetFunction();
+-  exports->Set(class_name, constructor_local);
++  Local<Function> constructor_local = Nan::GetFunction(tpl).ToLocalChecked();
++  Nan::Set(exports, class_name, constructor_local);
+   constructor.Reset(Nan::Persistent<Function>(constructor_local));
+ }
+ 
+@@ -87,10 +87,12 @@ void TreeCursor::GotoFirstChild(const Nan::FunctionCallbackInfo<Value> &info) {
+ 
+ void TreeCursor::GotoFirstChildForIndex(const Nan::FunctionCallbackInfo<Value> &info) {
+   TreeCursor *cursor = Nan::ObjectWrap::Unwrap<TreeCursor>(info.This());
+-  if (!info[0]->IsUint32()) {
++  auto maybe_index = Nan::To<uint32_t>(info[0]);
++  if (maybe_index.IsNothing()) {
+     Nan::ThrowTypeError("Argument must be an integer");
++    return;
+   }
+-  uint32_t goal_byte = info[0]->Uint32Value() * 2;
++  uint32_t goal_byte = maybe_index.FromJust() * 2;
+   int64_t child_index = ts_tree_cursor_goto_first_child_for_byte(&cursor->cursor_, goal_byte);
+   if (child_index < 0) {
+     info.GetReturnValue().Set(Nan::Null());
+@@ -120,7 +122,7 @@ void TreeCursor::EndPosition(const Nan::FunctionCallbackInfo<Value> &info) {
+ void TreeCursor::CurrentNode(const Nan::FunctionCallbackInfo<Value> &info) {
+   TreeCursor *cursor = Nan::ObjectWrap::Unwrap<TreeCursor>(info.This());
+   Local<String> key = Nan::New<String>("tree").ToLocalChecked();
+-  const Tree *tree = Tree::UnwrapTree(info.This()->Get(key));
++  const Tree *tree = Tree::UnwrapTree(Nan::Get(info.This(), key).ToLocalChecked());
+   TSNode node = ts_tree_cursor_current_node(&cursor->cursor_);
+   node_methods::MarshalNode(info, tree, node);
+ }
+@@ -128,7 +130,7 @@ void TreeCursor::CurrentNode(const Nan::FunctionCallbackInfo<Value> &info) {
+ void TreeCursor::Reset(const Nan::FunctionCallbackInfo<Value> &info) {
+   TreeCursor *cursor = Nan::ObjectWrap::Unwrap<TreeCursor>(info.This());
+   Local<String> key = Nan::New<String>("tree").ToLocalChecked();
+-  const Tree *tree = Tree::UnwrapTree(info.This()->Get(key));
++  const Tree *tree = Tree::UnwrapTree(Nan::Get(info.This(), key).ToLocalChecked());
+   TSNode node = node_methods::UnmarshalNode(tree);
+   ts_tree_cursor_reset(&cursor->cursor_, node);
+ }
+diff --git a/test/node_test.js b/test/node_test.js
+index 6455a9f..643ab3e 100644
+--- a/test/node_test.js
++++ b/test/node_test.js
+@@ -53,7 +53,7 @@ describe("Node", () => {
+   });
+ 
+   describe(".children", () => {
+-    it("returns an array of child nodes", () => {
++    it.only("returns an array of child nodes", () => {
+       const tree = parser.parse("x10 + 1000");
+       assert.equal(1, tree.rootNode.children.length);
+       const sumNode = tree.rootNode.firstChild.firstChild;
+diff --git a/test/parser_test.js b/test/parser_test.js
+index 1645104..a1f6d17 100644
+--- a/test/parser_test.js
++++ b/test/parser_test.js
+@@ -100,7 +100,7 @@ describe("Parser", () => {
+ 
+     it("reads from the given input", () => {
+       const parts = ["first", "_", "second", "_", "third"];
+-      const tree = parser.parse(() => parts.shift());
++      const tree = parser.parse((index) => parts.shift());
+       assert.equal(tree.rootNode.toString(), "(program (expression_statement (identifier)))");
+     });
+ 
+-- 
+2.23.0
+

Copied: bash-language-server/repos/community-testing-x86_64/PKGBUILD (from rev 501443, bash-language-server/trunk/PKGBUILD)
===================================================================
--- community-testing-x86_64/PKGBUILD	                        (rev 0)
+++ community-testing-x86_64/PKGBUILD	2019-08-24 06:12:05 UTC (rev 501444)
@@ -0,0 +1,49 @@
+# Maintainer: Felix Yan <felixonmars at archlinux.org>
+# Contributor: Maintainer: Maxim Baz <$pkgname at maximbaz dot com>
+
+pkgname=bash-language-server
+pkgver=1.5.6
+pkgrel=2
+pkgdesc="Bash language server implementation based on Tree Sitter and its grammar for Bash"
+arch=("x86_64")
+url="https://github.com/mads-hartmann/bash-language-server"
+license=("MIT")
+depends=("nodejs" "acorn")
+makedepends=("yarn" "typescript" "python2" "git")
+_treesitter_tag=0.15.8
+source=("https://github.com/mads-hartmann/$pkgname/archive/server-$pkgver.tar.gz"
+        "git+https://github.com/tree-sitter/node-tree-sitter#tag=v${_treesitter_tag}"
+        "0001-node-tree-sitter-nodejs-12-update.patch"
+        "bash-language-server-nodejs-12-update.patch")
+sha512sums=('d102374fab5b849321ee09bddcc22807b0b81347b2495ccd280bbb9c835f8c6e21199f7827f0ebddaecbabc4b9dec5af1ad69cd491304a9f8013ad3fb6c2b1d5'
+            'SKIP'
+            'f7720946ad85380e863072b89053498ece7364af48a85c03f32fd3f4e430e406ff5584291c321291910d3714c0ab9b99bbfd0a8ba184028256184f3f3d497dff'
+            'd46a755ad4877265aade7313cba0ef3cb49252038e9e7ff6d88a7975bc6333ac176a5456dff1446dfbcf4cc9717cd756ddcc9097a73435735fbfa40323e8b67c')
+
+prepare() {
+    cd "$srcdir/node-tree-sitter"
+    git submodule update --init --recursive
+    git apply ../0001-node-tree-sitter-nodejs-12-update.patch
+    yarn pack --filename ../tree-sitter-${_treesitter_tag}.tgz
+
+    cd "$srcdir/$pkgname-server-$pkgver"
+    patch -Np1 -i ../bash-language-server-nodejs-12-update.patch
+}
+
+build() {
+    cd "$srcdir/$pkgname-server-$pkgver"
+    yarn
+    cd server
+    PYTHON=python2 yarn run compile
+}
+
+package() {
+    install -d "$pkgdir/usr/lib/$pkgname"
+    cd "$pkgdir/usr/lib/$pkgname"
+    cp -a "$srcdir/$pkgname-server-$pkgver/server/"* .
+
+    rm -r node_modules/acorn
+
+    install -d "$pkgdir/usr/bin"
+    ln -s "/usr/lib/$pkgname/bin/main.js" "$pkgdir/usr/bin/$pkgname"
+}

Copied: bash-language-server/repos/community-testing-x86_64/bash-language-server-nodejs-12-update.patch (from rev 501443, bash-language-server/trunk/bash-language-server-nodejs-12-update.patch)
===================================================================
--- community-testing-x86_64/bash-language-server-nodejs-12-update.patch	                        (rev 0)
+++ community-testing-x86_64/bash-language-server-nodejs-12-update.patch	2019-08-24 06:12:05 UTC (rev 501444)
@@ -0,0 +1,15 @@
+diff --git a/server/package.json b/server/package.json
+index 88ed86a..cc71988 100644
+--- a/server/package.json
++++ b/server/package.json
+@@ -20,8 +20,8 @@
+     "glob": "^7.1.2",
+     "request": "^2.83.0",
+     "request-promise-native": "^1.0.5",
+-    "tree-sitter": "^0.13.22",
+-    "tree-sitter-bash": "^0.13.7",
++    "tree-sitter": "file:../../tree-sitter-0.15.8.tgz",
++    "tree-sitter-bash": "^0.16.0",
+     "turndown": "^4.0.2",
+     "urijs": "^1.19.1",
+     "vscode-languageserver": "^4.1.1"


More information about the arch-commits mailing list