fix: Open a new gradle project in VS Code and code completion won't work (#1019)

Author: CsCherrYY

extension/src/Extension.ts

@@ -40,7 +40,10 @@ import { DependencyTreeItem } from './views/gradleTasks/DependencyTreeItem';
 import { GRADLE_DEPENDENCY_REVEAL } from './views/gradleTasks/DependencyUtils';
 import { GradleDependencyProvider } from './dependencies/GradleDependencyProvider';
 import { getSpecificVersionStatus } from './views/gradleDaemons/util';
-import { startLanguageServer } from './languageServer/languageServer';
+import {
+  isLanguageServerStarted,
+  startLanguageServer,
+} from './languageServer/languageServer';
 import { DefaultProjectsTreeDataProvider } from './views/defaultProject/DefaultProjectsTreeDataProvider';
 
 export class Extension {
@@ -311,6 +314,9 @@ export class Extension {
     this.gradleWrapperWatcher.onDidChange(async (uri: vscode.Uri) => {
       logger.info('Gradle wrapper properties changed:', uri.fsPath);
       await this.restartServer();
+      if (isLanguageServerStarted) {
+        void vscode.commands.executeCommand('gradle.distributionChanged');
+      }
     });
   }
 

extension/src/languageServer/languageServer.ts

@@ -91,11 +91,15 @@ export async function startLanguageServer(
           serverOptions,
           clientOptions
         );
-        languageClient.onReady().then(resolve, (e) => {
-          resolve();
-          isLanguageServerStarted = true;
-          void vscode.window.showErrorMessage(e);
-        });
+        void languageClient.onReady().then(
+          () => {
+            isLanguageServerStarted = true;
+            resolve();
+          },
+          (e) => {
+            void vscode.window.showErrorMessage(e);
+          }
+        );
         const disposable = languageClient.start();
         context.subscriptions.push(disposable);
         context.subscriptions.push(

gradle-language-server/src/main/java/com/microsoft/gradle/GradleServices.java

@@ -83,7 +83,7 @@
 
 public class GradleServices implements TextDocumentService, WorkspaceService, LanguageClientAware {
 
-  public static final List<String> supportedCommands = List.of("gradle.getDependencies");
+  public static final List<String> supportedCommands = List.of("gradle.getDependencies", "gradle.distributionChanged");
 
   private LanguageClient client;
   private GradleFilesManager gradleFilesManager;
@@ -157,7 +157,7 @@ public void applySetting(Object settings) {
       this.getLibraryResolver().setGradleVersion((String) ((Map<?, ?>) settings).get("gradleVersion"));
       this.getLibraryResolver().setGradleWrapperEnabled((Boolean) ((Map<?, ?>) settings).get("gradleWrapperEnabled"));
       this.getLibraryResolver().setGradleUserHome((String) ((Map<?, ?>) settings).get("gradleUserHome"));
-      this.getLibraryResolver().resolve();
+      this.getLibraryResolver().resolveGradleAPI();
     }
   }
 
@@ -279,6 +279,7 @@ public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completio
         containingCall = call;
       }
     }
+    this.libraryResolver.loadGradleClasses();
     boolean javaPluginsIncluded = this.libraryResolver.isJavaPluginsIncluded(this.completionVisitor.getPlugins(uri));
     CompletionHandler handler = new CompletionHandler();
     // check again
@@ -318,6 +319,8 @@ public CompletableFuture<Object> executeCommand(ExecuteCommandParams params) {
       }
       List<DefaultDependencyItem> result = defaultDependenciesHandler.getDefaultDependencies(dependencies);
       return CompletableFuture.completedFuture(result);
+    } else if (command.equals("gradle.distributionChanged")) {
+      this.libraryResolver.resolveGradleAPI();
     }
     return CompletableFuture.completedFuture(null);
   }

gradle-language-server/src/main/java/com/microsoft/gradle/handlers/CompletionHandler.java

@@ -48,7 +48,7 @@ public List<CompletionItem> getCompletionItems(MethodCallExpression containingCa
     if (delegateClassName == null) {
       return Collections.emptyList();
     }
-    JavaClass delegateClass = resolver.getGradleLibraries().get(delegateClassName);
+    JavaClass delegateClass = resolver.getGradleClasses().get(delegateClassName);
     if (delegateClass == null) {
       return Collections.emptyList();
     }
@@ -61,13 +61,13 @@ private List<CompletionItem> getCompletionItemsFromClass(JavaClass javaClass, Gr
     }
     List<CompletionItem> results = new ArrayList<>();
     for (String superInterface : javaClass.getInterfaceNames()) {
-      if (resolver.getGradleLibraries().containsKey(superInterface)) {
-        results.addAll(getCompletionItemsFromClass(resolver.getGradleLibraries().get(superInterface), resolver, javaPluginsIncluded, resultSet));
+      if (resolver.getGradleClasses().containsKey(superInterface)) {
+        results.addAll(getCompletionItemsFromClass(resolver.getGradleClasses().get(superInterface), resolver, javaPluginsIncluded, resultSet));
       }
     }
     String superClass = javaClass.getSuperclassName();
-    if (resolver.getGradleLibraries().containsKey(superClass)) {
-      results.addAll(getCompletionItemsFromClass(resolver.getGradleLibraries().get(superClass), resolver, javaPluginsIncluded, resultSet));
+    if (resolver.getGradleClasses().containsKey(superClass)) {
+      results.addAll(getCompletionItemsFromClass(resolver.getGradleClasses().get(superClass), resolver, javaPluginsIncluded, resultSet));
     }
     List<String> methodNames = new ArrayList<>();
     Method[] methods = javaClass.getMethods();

gradle-language-server/src/main/java/com/microsoft/gradle/resolver/GradleLibraryResolver.java

@@ -36,17 +36,21 @@ public class GradleLibraryResolver {
 
   private static String JAVA_PLUGIN = "org.gradle.api.plugins.JavaPlugin";
 
-  private Map<String, JavaClass> gradleLibraries = new HashMap<>();
+  private Map<String, JavaClass> gradleClasses = new HashMap<>();
   private Set<String> javaConfigurations = new HashSet<>();
   private Set<String> javaPlugins = new HashSet<>();
   private String gradleHome;
   private String gradleVersion;
   private boolean gradleWrapperEnabled;
   private String gradleUserHome;
   private Path workspacePath;
+  private File coreAPI;
+  private File pluginAPI;
+  private boolean needToLoadClasses;
 
   public GradleLibraryResolver() {
     this.javaPlugins.addAll(Arrays.asList("java", "application", "groovy", "java-library", "war"));
+    this.needToLoadClasses = true;
   }
 
   public void setGradleHome(String gradleHome) {
@@ -69,47 +73,52 @@ public void setWorkspacePath(Path workspacePath) {
     this.workspacePath = workspacePath;
   }
 
-  public Map<String, JavaClass> getGradleLibraries() {
-    return this.gradleLibraries;
+  public Map<String, JavaClass> getGradleClasses() {
+    return this.gradleClasses;
   }
 
   public Set<String> getJavaConfigurations() {
     return this.javaConfigurations;
   }
 
-  public void resolve() {
+  public boolean resolveGradleAPI() {
+    this.needToLoadClasses = true;
     Path gradleUserHomePath = (this.gradleUserHome == null) ? Path.of(System.getProperty("user.home"), ".gradle")
         : Path.of(this.gradleUserHome);
-    File libFile = null;
     if (this.gradleWrapperEnabled) {
-      libFile = findLibWithWrapper(gradleUserHomePath);
+      this.coreAPI = findCoreAPIWithWrapper(gradleUserHomePath);
     } else if (this.gradleVersion != null) {
-      libFile = findLibWithDist(gradleUserHomePath, "gradle-" + this.gradleVersion);
+      this.coreAPI = findCoreAPIWithDist(gradleUserHomePath, "gradle-" + this.gradleVersion);
     } else if (this.gradleHome != null) {
-      Path libPath = Path.of(this.gradleHome).resolve("lib");
-      libFile = findLibFile(libPath.toFile());
+      this.coreAPI = findCoreAPI(Path.of(this.gradleHome).resolve("lib").toFile());
     } else {
-      return;
+      return false;
+    }
+    if (!isValidFile(this.coreAPI)) {
+      return false;
     }
-    if (libFile == null || !libFile.exists()) {
+    this.pluginAPI = findPluginAPI(this.coreAPI.toPath().getParent().resolve(Path.of("plugins")).toFile());
+    return isValidFile(this.pluginAPI);
+  }
+
+  public void loadGradleClasses() {
+    boolean isAPIValid = isValidFile(this.coreAPI) && isValidFile(this.pluginAPI);
+    if (!this.needToLoadClasses || (!isAPIValid && !this.resolveGradleAPI())) {
       return;
     }
     try {
-      JarFile libJar = new JarFile(libFile);
-      getGradleLibraries(libFile.toPath(), libJar);
-      File pluginLibFile = findPluginLibFile(libFile.toPath().getParent().resolve(Path.of("plugins")).toFile());
-      if (pluginLibFile == null) {
-        return;
-      }
-      JarFile pluginLibJar = new JarFile(pluginLibFile);
-      getGradleLibraries(pluginLibFile.toPath(), pluginLibJar);
-      resolveJavaConfigurations();
+      JarFile coreAPIJar = new JarFile(this.coreAPI);
+      loadClasses(this.coreAPI.toPath(), coreAPIJar);
+      JarFile pluginAPIJar = new JarFile(this.pluginAPI);
+      loadClasses(this.pluginAPI.toPath(), pluginAPIJar);
+      loadJavaConfigurations();
+      this.needToLoadClasses = false;
     } catch (Exception e) {
       // Do Nothing
     }
   }
 
-  private File findLibWithWrapper(Path gradleUserHomePath) {
+  private File findCoreAPIWithWrapper(Path gradleUserHomePath) {
     if (this.workspacePath == null) {
       return null;
     }
@@ -128,7 +137,7 @@ private File findLibWithWrapper(Path gradleUserHomePath) {
           Matcher matcher = p.matcher(content);
           if (matcher.find()) {
             String gradleDist = matcher.group(1);
-            return findLibWithDist(gradleUserHomePath, gradleDist);
+            return findCoreAPIWithDist(gradleUserHomePath, gradleDist);
           }
         }
       }
@@ -138,12 +147,12 @@ private File findLibWithWrapper(Path gradleUserHomePath) {
     return null;
   }
 
-  private File findLibWithDist(Path gradleUserHomePath, String gradleDist) {
+  private File findCoreAPIWithDist(Path gradleUserHomePath, String gradleDist) {
     Path distPath = gradleUserHomePath.resolve(Path.of("wrapper", "dists"));
     File distFolder = searchInFolder(gradleDist, distPath.toFile());
     if (distFolder != null && distFolder.exists()) {
       Path libPath = distFolder.toPath().resolve("lib");
-      return findLibFile(libPath.toFile());
+      return findCoreAPI(libPath.toFile());
     }
     return null;
   }
@@ -164,14 +173,15 @@ private File searchInFolder(String gradleDist, File folder) {
     return null;
   }
 
-  private File findLibFile(File folder) {
+  private File findCoreAPI(File folder) {
     for (File file : folder.listFiles()) {
       String name = file.getName();
       if (name.startsWith("gradle-core-api") && name.endsWith(".jar")) {
         return file;
       }
     }
-    // For Gradle version under 5.6, the name of library file is like gradle-core-${version}.jar
+    // For Gradle version under 5.6, the name of library file is like
+    // gradle-core-${version}.jar
     for (File file : folder.listFiles()) {
       String name = file.getName();
       if (name.startsWith("gradle-core") && name.endsWith(".jar")) {
@@ -181,7 +191,7 @@ private File findLibFile(File folder) {
     return null;
   }
 
-  private File findPluginLibFile(File folder) {
+  private File findPluginAPI(File folder) {
     for (File file : folder.listFiles()) {
       String name = file.getName();
       if (name.startsWith("gradle-plugins") && name.endsWith(".jar")) {
@@ -191,7 +201,7 @@ private File findPluginLibFile(File folder) {
     return null;
   }
 
-  private void getGradleLibraries(Path jarPath, JarFile jarFile) {
+  private void loadClasses(Path jarPath, JarFile jarFile) {
     Enumeration<JarEntry> entries = jarFile.entries();
     while (entries.hasMoreElements()) {
       JarEntry entry = entries.nextElement();
@@ -202,15 +212,15 @@ private void getGradleLibraries(Path jarPath, JarFile jarFile) {
       try {
         JavaClass javaClass = parser.parse();
         String className = javaClass.getClassName();
-        this.gradleLibraries.put(className, javaClass);
+        this.gradleClasses.put(className, javaClass);
       } catch (IOException | ClassFormatException e) {
         // Do Nothing
       }
     }
   }
 
-  private void resolveJavaConfigurations() {
-    JavaClass javaPluginClass = this.gradleLibraries.get(GradleLibraryResolver.JAVA_PLUGIN);
+  private void loadJavaConfigurations() {
+    JavaClass javaPluginClass = this.gradleClasses.get(GradleLibraryResolver.JAVA_PLUGIN);
     if (javaPluginClass == null) {
       return;
     }
@@ -222,7 +232,8 @@ private void resolveJavaConfigurations() {
   }
 
   private static String removeQuotes(String original) {
-    // for those fields parsed from class files, we get ""values"", so we remove the starting and ending quotes here
+    // for those fields parsed from class files, we get ""values"", so we remove the
+    // starting and ending quotes here
     if (original.length() < 3) {
       return original;
     }
@@ -237,4 +248,8 @@ public boolean isJavaPluginsIncluded(Set<String> plugins) {
     }
     return false;
   }
+
+  private static boolean isValidFile(File file) {
+    return file != null && file.exists();
+  }
 }