java/src/com/google/idea/blaze/java/libraries/BlazeSourceJarNavigationPolicy.java - intellij - Git at Google

 /*
  * Copyright 2017 The Bazel Authors. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.google.idea.blaze.java.libraries;

 import com.google.idea.blaze.base.model.BlazeProjectData;
 import com.google.idea.blaze.base.scope.BlazeContext;
 import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
 import com.google.idea.blaze.base.sync.SyncListener;
 import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
 import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
 import com.google.idea.common.experiments.BoolExperiment;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
 import com.intellij.openapi.project.ProjectManagerAdapter;
 import com.intellij.openapi.roots.LibraryOrderEntry;
 import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryUtil;
 import com.intellij.openapi.util.SimpleModificationTracker;
 import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassOwner;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiJavaFile;
 import com.intellij.psi.impl.compiled.ClsClassImpl;
 import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicyEx;
 import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.util.CachedValueProvider.Result;
 import com.intellij.psi.util.CachedValuesManager;
 import java.io.File;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import javax.annotation.Nullable;

 /**
  * A navigation policy that allows navigating to source (or reading javadocs) even when that source
  * isn't officially attached to the library in the project.
  *
  * <p>Attaching sources has been shown to slow indexing time because IntelliJ indexes all the source
  * files attached to project jars. This isn't a huge problem for non-Blaze projects, since the jars
  * change infrequently. With blaze, however, the jars are reshuffled after every blaze build and so
  * the indexing time increases dramatically if you attach too many of them.
  *
  * <p>This class attempts to work around that problem by providing a way to navigate to the source
  * without having that source actually indexed.
  */
 final class BlazeSourceJarNavigationPolicy extends ClsCustomNavigationPolicyEx {

   private static final BoolExperiment enabled =
       new BoolExperiment("blaze.source.jar.navigation.policy", true);
   static final BoolExperiment cacheEnabled =
       new BoolExperiment("blaze.source.jar.navigation.policy.cache", false);

   private final ConcurrentMap<Project, SimpleModificationTracker> projectSyncTrackers =
       new ConcurrentHashMap<>();

   public BlazeSourceJarNavigationPolicy() {
     ApplicationManager.getApplication()
         .getMessageBus()
         .connect()
         .subscribe(ProjectManager.TOPIC, new RemoveSyncTrackerOnProjectClosing());
   }

   @Nullable
   @Override
   public PsiFile getFileNavigationElement(ClsFileImpl file) {
     if (!enabled.getValue()) {
       return null;
     }

     return CachedValuesManager.getCachedValue(
         file,
         () -> {
           Result<PsiFile> result = getPsiFile(file);
           if (result == null) {
             result = notFound(file);
           }
           return result;
         });
   }

   @Nullable
   private Result<PsiFile> getPsiFile(ClsFileImpl file) {
     Project project = file.getProject();
     BlazeProjectData blazeProjectData =
         BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
     if (blazeProjectData == null) {
       return null;
     }

     VirtualFile root = getSourceJarRoot(project, blazeProjectData, file);
     if (root == null) {
       return null;
     }

     return getSourceFileResult(file, root);
   }

   @Nullable
   private VirtualFile getSourceJarRoot(
       Project project, BlazeProjectData blazeProjectData, PsiJavaFile clsFile) {

     Library library = findLibrary(project, clsFile);
     if (library == null || library.getFiles(OrderRootType.SOURCES).length != 0) {
       // If the library already has sources attached, no need to hunt for them.
       return null;
     }

     BlazeJarLibrary blazeLibrary =
         LibraryActionHelper.findLibraryFromIntellijLibrary(project, blazeProjectData, library);
     if (blazeLibrary == null) {
       return null;
     }

     File sourceJar =
         JarCache.getInstance(project)
             .getCachedSourceJar(blazeProjectData.artifactLocationDecoder, blazeLibrary);

     if (sourceJar == null && blazeLibrary.libraryArtifact.sourceJar != null) {
       sourceJar =
           blazeProjectData.artifactLocationDecoder.decode(blazeLibrary.libraryArtifact.sourceJar);
     }

     if (sourceJar == null) {
       return null;
     }

     VirtualFile vfsFile = VfsUtil.findFileByIoFile(sourceJar, true);
     if (vfsFile == null) {
       return null;
     }
     return JarFileSystem.getInstance().getJarRootForLocalFile(vfsFile);
   }

   @Nullable
   private Library findLibrary(Project project, PsiJavaFile clsFile) {
     OrderEntry libraryEntry = LibraryUtil.findLibraryEntry(clsFile.getVirtualFile(), project);
     if (!(libraryEntry instanceof LibraryOrderEntry)) {
       return null;
     }
     return ((LibraryOrderEntry) libraryEntry).getLibrary();
   }

   @Nullable
   private Result<PsiFile> getSourceFileResult(ClsFileImpl clsFile, VirtualFile root) {
     // This code is adapted from JavaPsiImplementationHelperImpl#getClsFileNavigationElement
     PsiClass[] classes = clsFile.getClasses();
     if (classes.length == 0) {
       return null;
     }

     String sourceFileName = ((ClsClassImpl) classes[0]).getSourceFileName();
     String packageName = clsFile.getPackageName();
     String relativePath =
         packageName.isEmpty()
             ? sourceFileName
             : packageName.replace('.', '/') + '/' + sourceFileName;

     VirtualFile source = root.findFileByRelativePath(relativePath);
     if (source != null && source.isValid()) {
       // Since we have an actual source jar tracked down, use that source jar as the modification
       // tracker. This means the result will continue to be cached unless that source jar changes.
       // If we didn't find a source jar, we use a modification tracker that invalidates on every
       // Blaze sync, which is less efficient.
       PsiFile psiSource = clsFile.getManager().findFile(source);
       if (psiSource instanceof PsiClassOwner) {
         return Result.create(psiSource, source);
       }
       return Result.create(null, source);
     }

     return null;
   }

   private Result<PsiFile> notFound(ClsFileImpl file) {
     // A "not-found" result is null, but depends on the project sync tracker, so it will expire
     // after the next blaze sync. This means we'll run this check again after every sync for files
     // that don't have source jars, but it's not a huge deal because checking for the source jar
     // only takes a few microseconds.
     projectSyncTrackers.putIfAbsent(file.getProject(), new SimpleModificationTracker());
     return Result.create(null, projectSyncTrackers.get(file.getProject()));
   }

   // In #api_163 and beyond, this can simply implement ProjectManagerListener
   private class RemoveSyncTrackerOnProjectClosing extends ProjectManagerAdapter {

     @Override
     public void projectClosing(Project project) {
       projectSyncTrackers.remove(project);
     }
   }

   class SyncTrackerUpdater extends SyncListener.Adapter {

     @Override
     public void afterSync(
         Project project, BlazeContext context, SyncMode syncMode, SyncResult syncResult) {
       SimpleModificationTracker modificationTracker = projectSyncTrackers.get(project);
       if (modificationTracker != null) {
         modificationTracker.incModificationCount();
       }
     }
   }
 }
	/*
	* Copyright 2017 The Bazel Authors. All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.google.idea.blaze.java.libraries;

	import com.google.idea.blaze.base.model.BlazeProjectData;
	import com.google.idea.blaze.base.scope.BlazeContext;
	import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
	import com.google.idea.blaze.base.sync.SyncListener;
	import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
	import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
	import com.google.idea.common.experiments.BoolExperiment;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.project.ProjectManager;
	import com.intellij.openapi.project.ProjectManagerAdapter;
	import com.intellij.openapi.roots.LibraryOrderEntry;
	import com.intellij.openapi.roots.OrderEntry;
	import com.intellij.openapi.roots.OrderRootType;
	import com.intellij.openapi.roots.libraries.Library;
	import com.intellij.openapi.roots.libraries.LibraryUtil;
	import com.intellij.openapi.util.SimpleModificationTracker;
	import com.intellij.openapi.vfs.JarFileSystem;
	import com.intellij.openapi.vfs.VfsUtil;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.psi.PsiClass;
	import com.intellij.psi.PsiClassOwner;
	import com.intellij.psi.PsiFile;
	import com.intellij.psi.PsiJavaFile;
	import com.intellij.psi.impl.compiled.ClsClassImpl;
	import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicyEx;
	import com.intellij.psi.impl.compiled.ClsFileImpl;
	import com.intellij.psi.util.CachedValueProvider.Result;
	import com.intellij.psi.util.CachedValuesManager;
	import java.io.File;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.ConcurrentMap;
	import javax.annotation.Nullable;

	/**
	* A navigation policy that allows navigating to source (or reading javadocs) even when that source
	* isn't officially attached to the library in the project.
	*
	* <p>Attaching sources has been shown to slow indexing time because IntelliJ indexes all the source
	* files attached to project jars. This isn't a huge problem for non-Blaze projects, since the jars
	* change infrequently. With blaze, however, the jars are reshuffled after every blaze build and so
	* the indexing time increases dramatically if you attach too many of them.
	*
	* <p>This class attempts to work around that problem by providing a way to navigate to the source
	* without having that source actually indexed.
	*/
	final class BlazeSourceJarNavigationPolicy extends ClsCustomNavigationPolicyEx {

	private static final BoolExperiment enabled =
	new BoolExperiment("blaze.source.jar.navigation.policy", true);
	static final BoolExperiment cacheEnabled =
	new BoolExperiment("blaze.source.jar.navigation.policy.cache", false);

	private final ConcurrentMap<Project, SimpleModificationTracker> projectSyncTrackers =
	new ConcurrentHashMap<>();

	public BlazeSourceJarNavigationPolicy() {
	ApplicationManager.getApplication()
	.getMessageBus()
	.connect()
	.subscribe(ProjectManager.TOPIC, new RemoveSyncTrackerOnProjectClosing());
	}

	@Nullable
	@Override
	public PsiFile getFileNavigationElement(ClsFileImpl file) {
	if (!enabled.getValue()) {
	return null;
	}

	return CachedValuesManager.getCachedValue(
	file,
	() -> {
	Result<PsiFile> result = getPsiFile(file);
	if (result == null) {
	result = notFound(file);
	}
	return result;
	});
	}

	@Nullable
	private Result<PsiFile> getPsiFile(ClsFileImpl file) {
	Project project = file.getProject();
	BlazeProjectData blazeProjectData =
	BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
	if (blazeProjectData == null) {
	return null;
	}

	VirtualFile root = getSourceJarRoot(project, blazeProjectData, file);
	if (root == null) {
	return null;
	}

	return getSourceFileResult(file, root);
	}

	@Nullable
	private VirtualFile getSourceJarRoot(
	Project project, BlazeProjectData blazeProjectData, PsiJavaFile clsFile) {

	Library library = findLibrary(project, clsFile);
	if (library == null \|\| library.getFiles(OrderRootType.SOURCES).length != 0) {
	// If the library already has sources attached, no need to hunt for them.
	return null;
	}

	BlazeJarLibrary blazeLibrary =
	LibraryActionHelper.findLibraryFromIntellijLibrary(project, blazeProjectData, library);
	if (blazeLibrary == null) {
	return null;
	}

	File sourceJar =
	JarCache.getInstance(project)
	.getCachedSourceJar(blazeProjectData.artifactLocationDecoder, blazeLibrary);

	if (sourceJar == null && blazeLibrary.libraryArtifact.sourceJar != null) {
	sourceJar =
	blazeProjectData.artifactLocationDecoder.decode(blazeLibrary.libraryArtifact.sourceJar);
	}

	if (sourceJar == null) {
	return null;
	}

	VirtualFile vfsFile = VfsUtil.findFileByIoFile(sourceJar, true);
	if (vfsFile == null) {
	return null;
	}
	return JarFileSystem.getInstance().getJarRootForLocalFile(vfsFile);
	}

	@Nullable
	private Library findLibrary(Project project, PsiJavaFile clsFile) {
	OrderEntry libraryEntry = LibraryUtil.findLibraryEntry(clsFile.getVirtualFile(), project);
	if (!(libraryEntry instanceof LibraryOrderEntry)) {
	return null;
	}
	return ((LibraryOrderEntry) libraryEntry).getLibrary();
	}

	@Nullable
	private Result<PsiFile> getSourceFileResult(ClsFileImpl clsFile, VirtualFile root) {
	// This code is adapted from JavaPsiImplementationHelperImpl#getClsFileNavigationElement
	PsiClass[] classes = clsFile.getClasses();
	if (classes.length == 0) {
	return null;
	}

	String sourceFileName = ((ClsClassImpl) classes[0]).getSourceFileName();
	String packageName = clsFile.getPackageName();
	String relativePath =
	packageName.isEmpty()
	? sourceFileName
	: packageName.replace('.', '/') + '/' + sourceFileName;

	VirtualFile source = root.findFileByRelativePath(relativePath);
	if (source != null && source.isValid()) {
	// Since we have an actual source jar tracked down, use that source jar as the modification
	// tracker. This means the result will continue to be cached unless that source jar changes.
	// If we didn't find a source jar, we use a modification tracker that invalidates on every
	// Blaze sync, which is less efficient.
	PsiFile psiSource = clsFile.getManager().findFile(source);
	if (psiSource instanceof PsiClassOwner) {
	return Result.create(psiSource, source);
	}
	return Result.create(null, source);
	}

	return null;
	}

	private Result<PsiFile> notFound(ClsFileImpl file) {
	// A "not-found" result is null, but depends on the project sync tracker, so it will expire
	// after the next blaze sync. This means we'll run this check again after every sync for files
	// that don't have source jars, but it's not a huge deal because checking for the source jar
	// only takes a few microseconds.
	projectSyncTrackers.putIfAbsent(file.getProject(), new SimpleModificationTracker());
	return Result.create(null, projectSyncTrackers.get(file.getProject()));
	}

	// In #api_163 and beyond, this can simply implement ProjectManagerListener
	private class RemoveSyncTrackerOnProjectClosing extends ProjectManagerAdapter {

	@Override
	public void projectClosing(Project project) {
	projectSyncTrackers.remove(project);
	}
	}

	class SyncTrackerUpdater extends SyncListener.Adapter {

	@Override
	public void afterSync(
	Project project, BlazeContext context, SyncMode syncMode, SyncResult syncResult) {
	SimpleModificationTracker modificationTracker = projectSyncTrackers.get(project);
	if (modificationTracker != null) {
	modificationTracker.incModificationCount();
	}
	}
	}
	}