update to lib-ruby-parser 3.0.0-8

iliabylich · iliabylich · commit fec5aec3e5e5 · 2021-03-10T22:15:10.000+03:00
diff --git a/.depend b/.depend
@@ -58,6 +58,27 @@ target/debug/token_rewriter.o: src/token_rewriter.cpp \
   src/token_rewriter.h src/token.h src/bytes.h src/byte_ptr.h src/loc.h \
   src/input.h
 
+target/debug/gen/messages/classes.o: src/gen/messages/classes.cpp \
+  src/gen/messages/classes.h src/gen/messages/../../bytes.h \
+  src/gen/messages/../../byte_ptr.h
+
+target/debug/gen/messages/make.o: src/gen/messages/make.cpp \
+  src/gen/messages/make.h src/gen/messages/../../error_level.h \
+  src/gen/messages/../../byte_ptr.h src/gen/messages/variant.h \
+  src/gen/messages/classes.h src/gen/messages/../../bytes.h \
+  src/gen/messages/../../message.h \
+  src/gen/messages/../../gen/messages/variant.h \
+  src/gen/messages/../../loc.h src/gen/messages/../../input.h \
+  src/gen/messages/../../diagnostic.h
+
+target/debug/gen/messages/render.o: src/gen/messages/render.cpp \
+  src/gen/messages/render.h src/gen/messages/../../error_level.h \
+  src/gen/messages/../../byte_ptr.h src/gen/messages/../../diagnostic.h \
+  src/gen/messages/../../bytes.h src/gen/messages/../../loc.h \
+  src/gen/messages/../../input.h src/gen/messages/../../message.h \
+  src/gen/messages/../../gen/messages/variant.h \
+  src/gen/messages/classes.h
+
 target/debug/gen/nodes/classes.o: src/gen/nodes/classes.cpp \
   src/gen/nodes/classes.h src/gen/nodes/../../loc.h \
   src/gen/nodes/../../bytes.h src/gen/nodes/../../byte_ptr.h \
diff --git a/lib-ruby-parser-cpp-bindings/Cargo.toml b/lib-ruby-parser-cpp-bindings/Cargo.toml
@@ -16,8 +16,8 @@ generate-bindings = ["bindgen", "lib-ruby-parser-nodes"]
 onig = ["lib-ruby-parser/onig"]
 
 [dependencies]
-lib-ruby-parser = "=3.0.0-7"
+lib-ruby-parser = "=3.0.0-8"
 
 [build-dependencies]
 bindgen = {version = "0.53.1", optional = true}
-lib-ruby-parser-nodes = {version = "0.11.0", optional = true}
+lib-ruby-parser-nodes = {version = "0.13.0", optional = true}
diff --git a/lib-ruby-parser-cpp-bindings/src/bindings.rs b/lib-ruby-parser-cpp-bindings/src/bindings.rs
@@ -1090,6 +1090,9 @@ extern "C" {
     pub fn make_encoding_error(level: ErrorLevel, loc: *mut Loc, error: BytePtr)
         -> *mut Diagnostic;
 }
+extern "C" {
+    pub fn make_invalid_multibyte_char(level: ErrorLevel, loc: *mut Loc) -> *mut Diagnostic;
+}
 extern "C" {
     pub fn make_ambiguous_ternary_operator(
         level: ErrorLevel,
diff --git a/lib-ruby-parser-cpp-bindings/src/gen/messages.rs b/lib-ruby-parser-cpp-bindings/src/gen/messages.rs
@@ -138,6 +138,9 @@ impl From<lib_ruby_parser::Diagnostic> for Ptr<bindings::Diagnostic> {
                 let error = BytePtr::from(error);
                 unsafe { bindings::make_encoding_error(level, loc, error) }
             },
+            lib_ruby_parser::DiagnosticMessage::InvalidMultibyteChar {  } => {
+                unsafe { bindings::make_invalid_multibyte_char(level, loc, ) }
+            },
             lib_ruby_parser::DiagnosticMessage::AmbiguousTernaryOperator { condition } => {
                 let condition = BytePtr::from(condition);
                 unsafe { bindings::make_ambiguous_ternary_operator(level, loc, condition) }
diff --git a/lib-ruby-parser-cpp-bindings/src/gen/render_message.rs b/lib-ruby-parser-cpp-bindings/src/gen/render_message.rs
@@ -471,6 +471,18 @@ pub extern "C" fn render_message_encoding_error(level: bindings::ErrorLevel, loc
     BytePtr::from(message)
 }
 
+#[no_mangle]
+pub extern "C" fn render_message_invalid_multibyte_char(level: bindings::ErrorLevel, loc: *mut bindings::Loc) -> BytePtr {
+    let level = lib_ruby_parser::ErrorLevel::from(level);
+    let loc = lib_ruby_parser::Loc::from(Ptr::new(loc));
+    
+    let message = lib_ruby_parser::DiagnosticMessage::InvalidMultibyteChar {  };
+    let diagnostic = lib_ruby_parser::Diagnostic::new(level, message, loc);
+
+    let message = diagnostic.render_message();
+    BytePtr::from(message)
+}
+
 #[no_mangle]
 pub extern "C" fn render_message_ambiguous_ternary_operator(level: bindings::ErrorLevel, loc: *mut bindings::Loc, condition: BytePtr) -> BytePtr {
     let level = lib_ruby_parser::ErrorLevel::from(level);
@@ -1532,6 +1544,19 @@ pub extern "C" fn render_encoding_error(level: bindings::ErrorLevel, loc: *mut b
     BytePtr::from(rendered)
 }
 
+#[no_mangle]
+pub extern "C" fn render_invalid_multibyte_char(level: bindings::ErrorLevel, loc: *mut bindings::Loc, input: BytePtr) -> BytePtr {
+    let level = lib_ruby_parser::ErrorLevel::from(level);
+    let loc = lib_ruby_parser::Loc::from(Ptr::new(loc));
+    let input = lib_ruby_parser::source::Input::from(input);
+    
+    let message = lib_ruby_parser::DiagnosticMessage::InvalidMultibyteChar {  };
+    let diagnostic = lib_ruby_parser::Diagnostic::new(level, message, loc);
+
+    let rendered = diagnostic.render(&input);
+    BytePtr::from(rendered)
+}
+
 #[no_mangle]
 pub extern "C" fn render_ambiguous_ternary_operator(level: bindings::ErrorLevel, loc: *mut bindings::Loc, condition: BytePtr, input: BytePtr) -> BytePtr {
     let level = lib_ruby_parser::ErrorLevel::from(level);
diff --git a/src/gen/messages/classes.cpp b/src/gen/messages/classes.cpp
@@ -159,6 +159,10 @@ UnterminatedUnicodeEscape::UnterminatedUnicodeEscape()
 EncodingError::EncodingError(std::string error)
 {
     this->error = error;
+}
+InvalidMultibyteChar::InvalidMultibyteChar()
+{
+    
 }
 AmbiguousTernaryOperator::AmbiguousTernaryOperator(std::string condition)
 {
@@ -501,6 +505,10 @@ bool EncodingError::operator==(const EncodingError &other)
 {
     return error == other.error;
 }
+bool InvalidMultibyteChar::operator==(const InvalidMultibyteChar &)
+{
+    return true;
+}
 bool AmbiguousTernaryOperator::operator==(const AmbiguousTernaryOperator &other)
 {
     return condition == other.condition;
diff --git a/src/gen/messages/classes.h b/src/gen/messages/classes.h
@@ -250,6 +250,12 @@ class EncodingError: public BaseDiagnosticMessage {
     explicit EncodingError(std::string error);
     bool operator==(const EncodingError &other);
 };
+class InvalidMultibyteChar: public BaseDiagnosticMessage {
+public:
+    
+    explicit InvalidMultibyteChar();
+    bool operator==(const InvalidMultibyteChar &other);
+};
 class AmbiguousTernaryOperator: public BaseDiagnosticMessage {
 public:
     std::string condition;
diff --git a/src/gen/messages/make.cpp b/src/gen/messages/make.cpp
@@ -279,6 +279,13 @@ Diagnostic *make_encoding_error(ErrorLevel level, Loc *loc, BytePtr error)
         std::make_unique<DiagnosticMessage>(std::make_unique<EncodingError>(byte_ptr_to_owned_string(error))),
         std::unique_ptr<Loc>(loc));
 }
+Diagnostic *make_invalid_multibyte_char(ErrorLevel level, Loc *loc)
+{
+    return new Diagnostic(
+        level,
+        std::make_unique<DiagnosticMessage>(std::make_unique<InvalidMultibyteChar>()),
+        std::unique_ptr<Loc>(loc));
+}
 Diagnostic *make_ambiguous_ternary_operator(ErrorLevel level, Loc *loc, BytePtr condition)
 {
     return new Diagnostic(
diff --git a/src/gen/messages/make.h b/src/gen/messages/make.h
@@ -50,6 +50,7 @@ Diagnostic *make_invalid_cvar_name(ErrorLevel level, Loc *loc, char c);
 Diagnostic *make_unknown_regex_options(ErrorLevel level, Loc *loc, BytePtr options);
 Diagnostic *make_unterminated_unicode_escape(ErrorLevel level, Loc *loc);
 Diagnostic *make_encoding_error(ErrorLevel level, Loc *loc, BytePtr error);
+Diagnostic *make_invalid_multibyte_char(ErrorLevel level, Loc *loc);
 Diagnostic *make_ambiguous_ternary_operator(ErrorLevel level, Loc *loc, BytePtr condition);
 Diagnostic *make_ambiguous_regexp(ErrorLevel level, Loc *loc);
 Diagnostic *make_else_without_rescue(ErrorLevel level, Loc *loc);
diff --git a/src/gen/messages/render.cpp b/src/gen/messages/render.cpp
@@ -128,6 +128,9 @@ BytePtr render_message_diagnostic(Diagnostic *diagnostic)
         if constexpr (std::is_same_v<MessageT, std::unique_ptr<EncodingError>>) {
             return render_message_encoding_error(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->error.c_str(), message->error.length()));
         }
+        if constexpr (std::is_same_v<MessageT, std::unique_ptr<InvalidMultibyteChar>>) {
+            return render_message_invalid_multibyte_char(diagnostic->level, diagnostic->loc.get());
+        }
         if constexpr (std::is_same_v<MessageT, std::unique_ptr<AmbiguousTernaryOperator>>) {
             return render_message_ambiguous_ternary_operator(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->condition.c_str(), message->condition.length()));
         }
@@ -391,6 +394,9 @@ BytePtr render_diagnostic(Diagnostic *diagnostic, BytePtr input)
         if constexpr (std::is_same_v<MessageT, std::unique_ptr<EncodingError>>) {
             return render_encoding_error(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->error.c_str(), message->error.length()), input);
         }
+        if constexpr (std::is_same_v<MessageT, std::unique_ptr<InvalidMultibyteChar>>) {
+            return render_invalid_multibyte_char(diagnostic->level, diagnostic->loc.get(), input);
+        }
         if constexpr (std::is_same_v<MessageT, std::unique_ptr<AmbiguousTernaryOperator>>) {
             return render_ambiguous_ternary_operator(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->condition.c_str(), message->condition.length()), input);
         }
diff --git a/src/gen/messages/render.h b/src/gen/messages/render.h
@@ -50,6 +50,7 @@ BytePtr render_message_invalid_cvar_name(ErrorLevel level, Loc *loc, char c);
 BytePtr render_message_unknown_regex_options(ErrorLevel level, Loc *loc, BytePtr options);
 BytePtr render_message_unterminated_unicode_escape(ErrorLevel level, Loc *loc);
 BytePtr render_message_encoding_error(ErrorLevel level, Loc *loc, BytePtr error);
+BytePtr render_message_invalid_multibyte_char(ErrorLevel level, Loc *loc);
 BytePtr render_message_ambiguous_ternary_operator(ErrorLevel level, Loc *loc, BytePtr condition);
 BytePtr render_message_ambiguous_regexp(ErrorLevel level, Loc *loc);
 BytePtr render_message_else_without_rescue(ErrorLevel level, Loc *loc);
@@ -136,6 +137,7 @@ BytePtr render_invalid_cvar_name(ErrorLevel level, Loc *loc, char c, BytePtr inp
 BytePtr render_unknown_regex_options(ErrorLevel level, Loc *loc, BytePtr options, BytePtr input);
 BytePtr render_unterminated_unicode_escape(ErrorLevel level, Loc *loc, BytePtr input);
 BytePtr render_encoding_error(ErrorLevel level, Loc *loc, BytePtr error, BytePtr input);
+BytePtr render_invalid_multibyte_char(ErrorLevel level, Loc *loc, BytePtr input);
 BytePtr render_ambiguous_ternary_operator(ErrorLevel level, Loc *loc, BytePtr condition, BytePtr input);
 BytePtr render_ambiguous_regexp(ErrorLevel level, Loc *loc, BytePtr input);
 BytePtr render_else_without_rescue(ErrorLevel level, Loc *loc, BytePtr input);
diff --git a/src/gen/messages/variant.h b/src/gen/messages/variant.h
@@ -48,6 +48,7 @@ using diagnostic_message_variant_t = std::variant<
     std::unique_ptr<UnknownRegexOptions>,
     std::unique_ptr<UnterminatedUnicodeEscape>,
     std::unique_ptr<EncodingError>,
+    std::unique_ptr<InvalidMultibyteChar>,
     std::unique_ptr<AmbiguousTernaryOperator>,
     std::unique_ptr<AmbiguousRegexp>,
     std::unique_ptr<ElseWithoutRescue>,
diff --git a/src/gen/nodes/classes.h b/src/gen/nodes/classes.h
@@ -848,6 +848,8 @@ class CSend
     // foo&.bar(42)
     //      ~~~
     // ```
+    //
+    // `None` in a very special case when method call is implicit (i.e. `foo&.()`)
     std::unique_ptr<Loc> selector_l;
     // Location of the open parenthesis
     //

Original file line number	Diff line number	Diff line change
`@@ -159,6 +159,10 @@ UnterminatedUnicodeEscape::UnterminatedUnicodeEscape()`
`159`	`159`	`EncodingError::EncodingError(std::string error)`
`160`	`160`	`{`
`161`	`161`	`this->error = error;`
	`162`	`+}`
	`163`	`+InvalidMultibyteChar::InvalidMultibyteChar()`
	`164`	`+{`
	`165`	`+`
`162`	`166`	`}`
`163`	`167`	`AmbiguousTernaryOperator::AmbiguousTernaryOperator(std::string condition)`
`164`	`168`	`{`
`@@ -501,6 +505,10 @@ bool EncodingError::operator==(const EncodingError &other)`
`501`	`505`	`{`
`502`	`506`	`return error == other.error;`
`503`	`507`	`}`
	`508`	`+bool InvalidMultibyteChar::operator==(const InvalidMultibyteChar &)`
	`509`	`+{`
	`510`	`+ return true;`
	`511`	`+}`
`504`	`512`	`bool AmbiguousTernaryOperator::operator==(const AmbiguousTernaryOperator &other)`
`505`	`513`	`{`
`506`	`514`	`return condition == other.condition;`
Original file line number	Diff line number	Diff line change
`@@ -279,6 +279,13 @@ Diagnostic make_encoding_error(ErrorLevel level, Loc loc, BytePtr error)`
`279`	`279`	`std::make_unique<DiagnosticMessage>(std::make_unique<EncodingError>(byte_ptr_to_owned_string(error))),`
`280`	`280`	`std::unique_ptr<Loc>(loc));`
`281`	`281`	`}`
	`282`	`+Diagnostic make_invalid_multibyte_char(ErrorLevel level, Loc loc)`
	`283`	`+{`
	`284`	`+ return new Diagnostic(`
	`285`	`+ level,`
	`286`	`+ std::make_unique<DiagnosticMessage>(std::make_unique<InvalidMultibyteChar>()),`
	`287`	`+ std::unique_ptr<Loc>(loc));`
	`288`	`+}`
`282`	`289`	`Diagnostic make_ambiguous_ternary_operator(ErrorLevel level, Loc loc, BytePtr condition)`
`283`	`290`	`{`
`284`	`291`	`return new Diagnostic(`
Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,9 @@ BytePtr render_message_diagnostic(Diagnostic *diagnostic)`
`128`	`128`	`if constexpr (std::is_same_v<MessageT, std::unique_ptr<EncodingError>>) {`
`129`	`129`	`return render_message_encoding_error(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->error.c_str(), message->error.length()));`
`130`	`130`	`}`
	`131`	`+ if constexpr (std::is_same_v<MessageT, std::unique_ptr<InvalidMultibyteChar>>) {`
	`132`	`+ return render_message_invalid_multibyte_char(diagnostic->level, diagnostic->loc.get());`
	`133`	`+ }`
`131`	`134`	`if constexpr (std::is_same_v<MessageT, std::unique_ptr<AmbiguousTernaryOperator>>) {`
`132`	`135`	`return render_message_ambiguous_ternary_operator(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->condition.c_str(), message->condition.length()));`
`133`	`136`	`}`
`@@ -391,6 +394,9 @@ BytePtr render_diagnostic(Diagnostic *diagnostic, BytePtr input)`
`391`	`394`	`if constexpr (std::is_same_v<MessageT, std::unique_ptr<EncodingError>>) {`
`392`	`395`	`return render_encoding_error(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->error.c_str(), message->error.length()), input);`
`393`	`396`	`}`
	`397`	`+ if constexpr (std::is_same_v<MessageT, std::unique_ptr<InvalidMultibyteChar>>) {`
	`398`	`+ return render_invalid_multibyte_char(diagnostic->level, diagnostic->loc.get(), input);`
	`399`	`+ }`
`394`	`400`	`if constexpr (std::is_same_v<MessageT, std::unique_ptr<AmbiguousTernaryOperator>>) {`
`395`	`401`	`return render_ambiguous_ternary_operator(diagnostic->level, diagnostic->loc.get(), make_byte_ptr(message->condition.c_str(), message->condition.length()), input);`
`396`	`402`	`}`