[rust bindings] Allow zero-length method disambiguation. (#132)

* Allow zero-length method disambiguation.

parse_symbol was failing on a bunch of rust symbols that look like
"rust-analyzer cargo test_rust_dependency 0.1.0 MyType#new()." with
`Err(InvalidIdentifier("method disambiguator"))`.

The problem is that the method descriptor was attempting to use
peek to look for the character after the opening "(" to see if it was
a ")", but the index had already been incremented, so peek would see
the "." closing character instead of the ")".

I also have a change in this patch to disable automatic doctests
because `cargo test` is failing for me locally without this because
it seems to view the inlined protobuf schema as a doctest and
reasonably has trouble parsing the schema as valid rust code.  I am
not able to delve into the general machinery around the "generated"
directory at this time, but it seems nice for the tests to pass, so
this seems like a reasonable band-aid.

---------

Co-authored-by: TJ DeVries <devries.timothyj@gmail.com>

Author: asutherland

bindings/rust/Cargo.lock

@@ -24,3 +24,5 @@ pretty_assertions = "1.2.1"
 [lib]
 name = "scip"
 path = "src/mod.rs"
+# disable doctests because generated/scip.rs has a perceived doctest.
+doctest = false

bindings/rust/Cargo.toml

@@ -315,12 +315,11 @@ impl SymbolParser {
                 self.index += 1;
                 match suffix {
                     '(' => {
-                        let disambiguator = match self.peek_next() {
-                            Some(c) => match c {
-                                ')' => "".to_string(),
-                                _ => self.accept_identifier("method disambiguator")?,
-                            },
-                            None => "".to_string(),
+                        // We are not peeking here because we already advanced
+                        // past suffix.
+                        let disambiguator = match self.current()? {
+                            ')' => "".to_string(),
+                            _ => self.accept_identifier("method disambiguator")?,
                         };
 
                         self.accept_character(')', "closing method")?;
@@ -430,4 +429,58 @@ mod test {
             format_symbol(parse_symbol(input_symbol).expect("java symbol"))
         )
     }
+
+    #[test]
+    fn parses_rust_method_no_disambiguator() {
+        let input_symbol = "rust-analyzer cargo test_rust_dependency 0.1.0 MyType#new().";
+
+        assert_eq!(
+            parse_symbol(input_symbol).expect("rust symbol"),
+            Symbol {
+                scheme: "rust-analyzer".to_string(),
+                package: Package::new_with_values("cargo", "test_rust_dependency", "0.1.0"),
+                descriptors: vec![
+                    new_descriptor("MyType".to_string(), descriptor::Suffix::Type),
+                    new_descriptor_with_disambiguator(
+                        "new".to_string(),
+                        descriptor::Suffix::Method,
+                        "".to_string(),
+                    ),
+                ],
+                special_fields: SpecialFields::default(),
+            }
+        );
+
+        assert_eq!(
+            input_symbol,
+            format_symbol(parse_symbol(input_symbol).expect("rust symbol"))
+        )
+    }
+
+    #[test]
+    fn parses_rust_method_with_disambiguator() {
+        let input_symbol = "rust-analyzer cargo test_rust_dependency 0.1.0 MyType#new(test).";
+
+        assert_eq!(
+            parse_symbol(input_symbol).expect("rust symbol"),
+            Symbol {
+                scheme: "rust-analyzer".to_string(),
+                package: Package::new_with_values("cargo", "test_rust_dependency", "0.1.0"),
+                descriptors: vec![
+                    new_descriptor("MyType".to_string(), descriptor::Suffix::Type),
+                    new_descriptor_with_disambiguator(
+                        "new".to_string(),
+                        descriptor::Suffix::Method,
+                        "test".to_string(),
+                    ),
+                ],
+                special_fields: SpecialFields::default(),
+            }
+        );
+
+        assert_eq!(
+            input_symbol,
+            format_symbol(parse_symbol(input_symbol).expect("rust symbol"))
+        )
+    }
 }