fix: don't choke on scala/Function.

This took me an embarrassingly long time to catch what was going on ha.
But in the `SignatureFormatter` we special case things like `Function1`
to ensure we don't print `(A) => B` and instead `A => B`. We do this by
looking for symbols that start with `scala/Function`. However, the Scala
codebase has a `scala/Function.` object that causes this logic to trip
up. This change introduces another check to ensure that when we are in
Scala and see a symbol starting with `scala/Function` that it's not
`scala/Funtion.`.

This should get indexing working on the Scala codebase again.

Refs: #475

Author: ckipp01

scip-semanticdb/src/main/java/com/sourcegraph/scip_semanticdb/SignatureFormatter.java

@@ -23,6 +23,8 @@ public class SignatureFormatter {
 
   private static final Type NOTHING_SYMBOL = typeRef("scala/Nothing#");
   private static final String FUNCTION_SYMBOL_PREFIX = "scala/Function";
+  // Special case scala/Function object to not confluce with Function1 for example
+  private static final String FUNCTION_OBJECT = "scala/Function.";
   private static final String TUPLE_SYMBOL_PREFIX = "scala/Tuple";
   private static final String ARRAY_SYMBOL = "scala/Array#";
   private static final String ENUM_SYMBOL = "java/lang/Enum#";
@@ -557,7 +559,9 @@ private String formatType(Type type) {
           b.append(formatType(typeRef.getTypeArguments(0)));
           b.append("[]");
         }
-      } else if (isScala && typeRef.getSymbol().startsWith(FUNCTION_SYMBOL_PREFIX)) {
+      } else if (isScala
+          && typeRef.getSymbol().startsWith(FUNCTION_SYMBOL_PREFIX)
+          && !typeRef.getSymbol().startsWith(FUNCTION_OBJECT)) {
         int n = typeRef.getTypeArgumentsCount() - 1;
         if (n == 0) {
           // Special-case for Function1[A, B]: don't wrap `A`  in parenthesis like this `(A) => B`