Skip to content

Add referenced libraries as reference container #113

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Flanker32 merged 8 commits into from
Nov 20, 2018
Merged

Add referenced libraries as reference container #113

Changes from 5 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
c728c6f
Add referenced libraries as reference container
Flanker32 Nov 19, 2018
1656e5e
Merge branch 'master' into hanxiao_referlibs
andxu Nov 19, 2018
1946e30
Add support for Referenced Variable
Flanker32 Nov 20, 2018
749e4d3
Merge branch 'hanxiao_referlibs' of https://github.com/Microsoft/vsco…
Flanker32 Nov 20, 2018
db123a3
Resolve comments
Flanker32 Nov 20, 2018
b13f924
Resolve comments
Flanker32 Nov 20, 2018
2f72289
Set entry kind to BINARY for referenced variable which refers to folder
Flanker32 Nov 20, 2018
35efcfd
Resolve comments
Flanker32 Nov 20, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
152 changes: 111 additions & 41 deletions jdtls.ext/com.microsoft.jdtls.ext.core/src/com/microsoft/jdtls/ext/core/PackageCommand.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@
*******************************************************************************/
package com.microsoft.jdtls.ext.core;

import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
Expand Down Expand Up @@ -67,6 +68,10 @@ public class PackageCommand {

private static final String DEFAULT_PACKAGE_DISPLAYNAME = "(default package)";

private static final String REFERENCED_LIBRARIES_PATH = "REFERENCED_LIBRARIES_PATH";

private static final String REFERENCED_LIBRARIES_CONTAINER_NAME = "Referenced Libraries";

private static final Gson gson = new GsonBuilder().registerTypeAdapterFactory(new CollectionTypeAdapterFactory())
.registerTypeAdapterFactory(new EnumTypeAdapterFactory()).create();

Expand Down Expand Up @@ -97,7 +102,6 @@ public static List<PackageNode> getChildren(List<Object> arguments, IProgressMon
throw new IllegalArgumentException("Should have at least one arugment for getChildren");
}
PackageParams params = gson.fromJson(gson.toJson(arguments.get(0)), PackageParams.class);

BiFunction<PackageParams, IProgressMonitor, List<PackageNode>> loader = commands.get(params.getKind());
if (loader == null) {
throw new CoreException(new Status(IStatus.ERROR, JdtlsExtActivator.PLUGIN_ID, String.format("Unknown classpath item type: %s", params.getKind())));
Expand Down Expand Up @@ -144,7 +148,13 @@ public static List<PackageNode> resolvePath(List<Object> arguments, IProgressMon
IPackageFragmentRoot pkgRoot = (IPackageFragmentRoot) packageFragment.getParent();
PackageNode rootNode = null;
if (typeRoot instanceof IClassFile) {
rootNode = new PackageRootNode(pkgRoot.getElementName(), pkgRoot.getPath().toPortableString(), NodeKind.PACKAGEROOT, pkgRoot.getKind());
IClasspathEntry entry = pkgRoot.getRawClasspathEntry();
// Process Referenced Variable
if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
rootNode = getNodeFromClasspathVariable(entry);
} else {
rootNode = new PackageRootNode(pkgRoot.getElementName(), pkgRoot.getPath().toPortableString(), NodeKind.PACKAGEROOT, pkgRoot.getKind());
}
} else {
rootNode = new PackageRootNode(ExtUtils.removeProjectSegment(typeRoot.getJavaProject().getElementName(), pkgRoot.getPath()).toPortableString(),
pkgRoot.getPath().toPortableString(), NodeKind.PACKAGEROOT, pkgRoot.getKind());
Expand All @@ -154,8 +164,14 @@ public static List<PackageNode> resolvePath(List<Object> arguments, IProgressMon
if (typeRoot instanceof IClassFile) {
IClasspathEntry entry = pkgRoot.getRawClasspathEntry();
IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), typeRoot.getJavaProject());
PackageNode containerNode = new ContainerNode(container.getDescription(), container.getPath().toPortableString(), NodeKind.CONTAINER,
entry.getEntryKind());
PackageNode containerNode = null;
if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY || entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
containerNode = new ContainerNode(REFERENCED_LIBRARIES_CONTAINER_NAME, REFERENCED_LIBRARIES_PATH, NodeKind.CONTAINER,
IClasspathEntry.CPE_CONTAINER);
} else {
containerNode = new ContainerNode(container.getDescription(), container.getPath().toPortableString(), NodeKind.CONTAINER,
entry.getEntryKind());
}
result.add(containerNode);
}
result.add(rootNode);
Expand All @@ -174,36 +190,83 @@ public static List<PackageNode> resolvePath(List<Object> arguments, IProgressMon
*/
private static List<PackageNode> getContainers(PackageParams query, IProgressMonitor pm) {
IJavaProject javaProject = getJavaProject(query.getProjectUri());

if (javaProject != null) {
try {
IClasspathEntry[] references = javaProject.getRawClasspath();
return Arrays.stream(references).map(entry -> {
try {
entry = JavaCore.getResolvedClasspathEntry(entry);
IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
// HACK: There is an initialization issue for the first container.
if (container == null) {
container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
}

if (container != null) {
return new ContainerNode(container.getDescription(), container.getPath().toPortableString(), NodeKind.CONTAINER,
entry.getEntryKind());
}
} catch (CoreException e) {
// Ignore it
}
return null;
}).filter(containerNode -> containerNode != null).collect(Collectors.toList());
List<PackageNode> result = Arrays.stream(references)
.filter(entry -> entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY && entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE)
.map(entry -> getNodeFromClasspathEntry(entry, javaProject, NodeKind.CONTAINER)).filter(containerNode -> containerNode != null)
.collect(Collectors.toList());
List<IClasspathEntry> referenceLibraries = Arrays.stream(references)
.filter(entry -> entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY || entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE)
.collect(Collectors.toList());
if (referenceLibraries.size() > 0) {
result.add(new ContainerNode(REFERENCED_LIBRARIES_CONTAINER_NAME, REFERENCED_LIBRARIES_PATH, NodeKind.CONTAINER,
IClasspathEntry.CPE_CONTAINER));
}
return result;
} catch (CoreException e) {
JdtlsExtActivator.logException("Problem load project library ", e);
}
}
return Collections.emptyList();
}

/**
* Get the correspond node of classpath, it may be container or a package root
*
* @param classpathEntry
* classpath entry
* @param javaProject
* correspond java project
* @param nodeKind
* could be CONTAINER or PACKAGEROOT(for referenced libraries)
* @return correspond PackageNode of classpath entry
*/
private static PackageNode getNodeFromClasspathEntry(IClasspathEntry classpathEntry, IJavaProject javaProject, NodeKind nodeKind) {
try {
IClasspathEntry entry = JavaCore.getResolvedClasspathEntry(classpathEntry);
IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
// HACK: There is an initialization issue for the first container.
if (container == null) {
container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
}
if (container != null) {
switch (nodeKind) {
case CONTAINER:
return new ContainerNode(container.getDescription(), container.getPath().toPortableString(), nodeKind, entry.getEntryKind());
case PACKAGEROOT:
// Use package name as package root name
String[] pathSegments = container.getPath().segments();
return new PackageRootNode(pathSegments[pathSegments.length - 1], container.getPath().toPortableString(), nodeKind,
IClasspathEntry.CPE_PROJECT);
default:
return null;
}
}
} catch (CoreException e) {
JdtlsExtActivator.logException("Problems when convert classpath entry to package node ", e);
}
return null;
}

/**
* Get correspond node of referenced variable
*
* @param classpathEntry
* referenced cariable's classpath entry
* @return correspond package node
*/
private static PackageNode getNodeFromClasspathVariable(IClasspathEntry classpathEntry) {
IClasspathEntry entry = JavaCore.getResolvedClasspathEntry(classpathEntry);
String name = classpathEntry.getPath().toPortableString();
String path = entry.getPath().toPortableString();
boolean isDirectory = new File(path).isDirectory();
return new PackageRootNode(name, path, NodeKind.PACKAGEROOT, isDirectory ? IClasspathEntry.CPE_LIBRARY : IClasspathEntry.CPE_PROJECT);
}

private static List<PackageNode> getPackageFragmentRoots(PackageParams query, IProgressMonitor pm) {
ArrayList<PackageNode> children = new ArrayList<>();
IJavaProject javaProject = getJavaProject(query.getProjectUri());

if (javaProject != null) {
Expand All @@ -217,7 +280,6 @@ private static List<PackageNode> getPackageFragmentRoots(PackageParams query, IP
}
}
if (containerEntry != null) {
ArrayList<PackageNode> children = new ArrayList<>();
IPackageFragmentRoot[] packageFragmentRoots = javaProject.findPackageFragmentRoots(containerEntry);
for (IPackageFragmentRoot fragmentRoot : packageFragmentRoots) {
String displayName = fragmentRoot.getElementName();
Expand All @@ -232,6 +294,16 @@ private static List<PackageNode> getPackageFragmentRoots(PackageParams query, IP
}
}
return children;
} else if (query.getPath().equals(REFERENCED_LIBRARIES_PATH)) {
// Process referenced libraries
List<PackageNode> referLibs = Arrays.stream(references).filter(entry -> entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
.map(classpath -> getNodeFromClasspathEntry(classpath, javaProject, NodeKind.PACKAGEROOT)).filter(entry -> entry != null)
.collect(Collectors.toList());
List<PackageNode> referVariables = Arrays.stream(references).filter(entry -> entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE)
.map(classpath -> getNodeFromClasspathVariable(classpath)).filter(entry -> entry != null).collect(Collectors.toList());
children.addAll(referLibs);
children.addAll(referVariables);
return children;
}
} catch (CoreException e) {
JdtlsExtActivator.logException("Problem load project JAR entries ", e);
Expand All @@ -243,9 +315,7 @@ private static List<PackageNode> getPackageFragmentRoots(PackageParams query, IP

private static List<PackageNode> getPackages(PackageParams query, IProgressMonitor pm) {
IJavaProject javaProject = getJavaProject(query.getProjectUri());

if (javaProject != null) {

try {
IPackageFragmentRoot packageRoot = javaProject.findPackageFragmentRoot(Path.fromPortableString(query.getRootPath()));
if (packageRoot == null) {
Expand Down Expand Up @@ -274,7 +344,7 @@ private static List<PackageNode> getRootTypes(PackageParams query, IProgressMoni
if (packageFragment != null) {
IJavaElement[] types = packageFragment.getChildren();
Object[] nonJavaResources = packageFragment.getNonJavaResources();
List<PackageNode> rootTypeNodes = Arrays.stream(types).filter(typeRoot -> !typeRoot.getElementName().contains("$")).map(typeRoot -> {
List<PackageNode> rootTypeNodes = Arrays.stream(types).filter(typeRoot -> !typeRoot.getElementName().contains("$")).map(typeRoot -> {
PackageNode item = new TypeRootNode(typeRoot.getElementName(), typeRoot.getPath().toPortableString(), NodeKind.TYPEROOT,
typeRoot instanceof IClassFile ? TypeRootNode.K_BINARY : TypeRootNode.K_SOURCE);
if (typeRoot instanceof ICompilationUnit) {
Expand All @@ -289,20 +359,20 @@ private static List<PackageNode> getRootTypes(PackageParams query, IProgressMoni
}
// when .java files and other .properties files are mixed up
rootTypeNodes.addAll(
Arrays.stream(nonJavaResources).filter(resource -> resource instanceof IFile || resource instanceof JarEntryFile).map(resource -> {
if (resource instanceof IFile) {
IFile file = (IFile) resource;
PackageNode item = new PackageNode(file.getName(), file.getFullPath().toPortableString(), NodeKind.FILE);
item.setUri(JDTUtils.getFileURI(file));
return item;
} else {
JarEntryFile file = (JarEntryFile) resource;
PackageNode entry = new PackageNode(file.getName(), file.getFullPath().toPortableString(), NodeKind.FILE);
entry.setUri(ExtUtils.toUri((JarEntryFile) resource));
return entry;
}

}).collect(Collectors.toList()));
Arrays.stream(nonJavaResources).filter(resource -> resource instanceof IFile || resource instanceof JarEntryFile).map(resource -> {
if (resource instanceof IFile) {
IFile file = (IFile) resource;
PackageNode item = new PackageNode(file.getName(), file.getFullPath().toPortableString(), NodeKind.FILE);
item.setUri(JDTUtils.getFileURI(file));
return item;
} else {
JarEntryFile file = (JarEntryFile) resource;
PackageNode entry = new PackageNode(file.getName(), file.getFullPath().toPortableString(), NodeKind.FILE);
entry.setUri(ExtUtils.toUri((JarEntryFile) resource));
return entry;
}

}).collect(Collectors.toList()));
return rootTypeNodes;
}
} catch (CoreException e) {
Expand Down