Fix issue #17, inner class resolving incorrecly from another file

quarnster · quarnster · commit f71a9eebb78b · 2012-05-04T08:08:11.000+02:00
diff --git a/SublimeJava.class b/SublimeJava.class
diff --git a/SublimeJava.java b/SublimeJava.java
@@ -27,6 +27,7 @@
 import java.net.URL;
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
+import java.util.*;
 
 
 public class SublimeJava
@@ -66,6 +67,19 @@ public static String[] getCompletion(Field f, String filter)
     }
     private static final String sep = ";;--;;";
 
+    private static String getClassname(String pack, String clazz)
+    {
+        if (pack.endsWith(".*"))
+        {
+            return pack.substring(0, pack.length()-2) + "." + clazz;
+        }
+        else if (pack.length() != 0)
+        {
+            return pack + "$" + clazz;
+        }
+        return clazz;
+    }
+
     public static void main(String... args)
     {
         try
@@ -78,14 +92,41 @@ public static void main(String... args)
             else if (args[0].equals("-findclass"))
             {
                 String line = null;
+                ArrayList<String> packages = new ArrayList<String>();
                 try
                 {
                     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
                     while ((line = in.readLine()) != null)
                     {
+                        packages.add(line);
+                    }
+                }
+                catch (Exception e)
+                {
+                }
+                for (String pack : packages)
+                {
+                    try
+                    {
+                        Class c = Class.forName(getClassname(pack, args[1]));
+                        System.out.println("" + c.getName());
+                        return;
+                    }
+                    catch (Exception e)
+                    {
+                    }
+                }
+                // Still haven't found anything, so try to see if it's an internal class
+                for (String pack : packages)
+                {
+                    String classname = getClassname(pack, args[1]);
+                    while (classname.indexOf('.') != -1)
+                    {
+                        int idx = classname.lastIndexOf('.');
+                        classname = classname.substring(0, idx) + "$" + classname.substring(idx+1);
                         try
                         {
-                            Class c = Class.forName(line + "." + args[1]);
+                            Class c = Class.forName(classname);
                             System.out.println("" + c.getName());
                             return;
                         }
@@ -94,9 +135,6 @@ else if (args[0].equals("-findclass"))
                         }
                     }
                 }
-                catch (Exception e)
-                {
-                }
                 return;
             }
             Class<?> c = Class.forName(args[1]);
diff --git a/sublimejava.py b/sublimejava.py
@@ -46,7 +46,6 @@
 
 
 scriptdir = os.path.dirname(os.path.abspath(__file__))
-enableCache = True
 
 
 def get_settings():
@@ -324,48 +323,52 @@ def find_absolute_of_type(self, data, full_data, type):
                 return type
             return "%s.%s" % (thispackage, type)
         outer = type.split("$")[0]
+        outer = outer.split(".")[0]
         regex = "[ \t]*import[ \t]+(.*)\.%s" % outer
         match = re.search(regex, data)
         if not match is None:
-            return "%s.%s" % (match.group(1), type)
+            classname = "%s.%s" % (match.group(1), type)
+            if cache.get_cached_class_exists(classname):
+                return classname
+            # Try and see if it's an inner class then
+            count = 0
+            while "." in classname and count < 10:
+                count += 1
+                classname = "%s$%s" % (classname[:classname.rfind(".")], classname[classname.rfind(".")+1:])
+                print classname
+                if cache.get_cached_class_exists(classname):
+                    return classname
 
         # Couldn't find the absolute name of this class so try to
         # see if it's in one of the packages imported as
         # "import package.*;", or in java.lang
         #
-        packages = re.findall("[ \t]*import[ \t]+(.*)\.\*;", data)
-        packages.append("java.lang")
-        packages.append(thispackage)
-        if enableCache:
-            packages.append("")  # for int, boolean, etc
-            for package in packages:
-                classname = package + "." + type
-                if cache.get_cached_class_exists(classname):
-                    return classname
+        packages = re.findall("[ \t]*import[ \t]+(.*);", data)
+        packages.append("java.lang.*")
+        packages.append(thispackage + ".*")
+        packages.append("")  # for int, boolean, etc
+        for package in packages:
+            classname = type
+            if package.endswith(".*"):
+                classname = package[:-2] + "." + type
+            elif len(package):
+                classname = package + "$" + type
+            if cache.get_cached_class_exists(classname):
+                return classname
 
         # Couldn't find a cached version, invoke java
-        output = run_java("%s -findclass %s" % (get_cmd(), type), "\n".join(packages)).strip()
-        if len(output) and enableCache:
+        output = run_java("%s -findclass '%s'" % (get_cmd(), type), "\n".join(packages)).strip()
+        if len(output):
             cache.cache_class(output)
         if len(output) == 0 and "." in type:
             return self.find_absolute_of_type(data, full_data, type.replace(".", "$"))
         return output
 
     def complete_class(self, absolute_classname, prefix):
-        if enableCache:
-            return cache.complete(absolute_classname, prefix)
-        else:
-            stdout = run_java("%s -complete %s %s" % (get_cmd(), absolute_classname, prefix))
-            ret = [tuple(line.split(";;--;;")) for line in stdout.split("\n")[:-1]]
-            return sorted(ret, key=lambda a: a[0])
+        return cache.complete(absolute_classname, prefix)
 
     def get_return_type(self, absolute_classname, prefix):
-        ret = ""
-        if enableCache:
-            ret = cache.get_return_type(absolute_classname, prefix)
-        else:
-            stdout = run_java("%s -returntype %s %s" % (get_cmd(), absolute_classname, prefix))
-            ret = stdout.strip()
+        ret = cache.get_return_type(absolute_classname, prefix)
         match = re.search("(\[L)?([^;]+)", ret)
         if match:
             return match.group(2)
