jdk.jshell.SourceCodeAnalysisImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javac Show documentation
Show all versions of javac Show documentation
A repackaged copy of javac for Error Prone to depend on
/*
* Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.jshell;
import jdk.jshell.SourceCodeAnalysis.Completeness;
import com.sun.source.tree.AssignmentTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.ErroneousTree;
import com.sun.source.tree.ExpressionTree;
import com.sun.source.tree.IdentifierTree;
import com.sun.source.tree.ImportTree;
import com.sun.source.tree.MemberSelectTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.NewClassTree;
import com.sun.source.tree.Scope;
import com.sun.source.tree.Tree;
import com.sun.source.tree.Tree.Kind;
import com.sun.source.tree.VariableTree;
import com.sun.source.util.SourcePositions;
import com.sun.source.util.TreePath;
import com.sun.source.util.TreePathScanner;
import com.sun.tools.javac.api.JavacScope;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Symbol.CompletionFailure;
import com.sun.tools.javac.code.Symbol.VarSymbol;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.ClassType;
import com.sun.tools.javac.util.DefinedBy;
import com.sun.tools.javac.util.DefinedBy.Api;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.util.Pair;
import jdk.jshell.CompletenessAnalyzer.CaInfo;
import jdk.jshell.TaskFactory.AnalyzeTask;
import jdk.jshell.TaskFactory.ParseTask;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.function.Predicate;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeMirror;
import static jdk.internal.jshell.debug.InternalDebugControl.DBG_COMPA;
import java.io.IOException;
import java.net.URI;
import java.nio.file.DirectoryStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toCollection;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.PackageElement;
import javax.lang.model.element.QualifiedNameable;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Types;
import javax.tools.JavaFileManager.Location;
import javax.tools.StandardLocation;
import static jdk.jshell.Util.REPL_DOESNOTMATTER_CLASS_NAME;
/**
* The concrete implementation of SourceCodeAnalysis.
* @author Robert Field
*/
class SourceCodeAnalysisImpl extends SourceCodeAnalysis {
private static final Map PATH_TO_INDEX = new HashMap<>();
private static final ExecutorService INDEXER = Executors.newFixedThreadPool(1, r -> {
Thread t = new Thread(r);
t.setDaemon(true);
t.setUncaughtExceptionHandler((thread, ex) -> ex.printStackTrace());
return t;
});
private final JShell proc;
private final CompletenessAnalyzer ca;
private final Map currentIndexes = new HashMap<>();
private int indexVersion;
private int classpathVersion;
private final Object suspendLock = new Object();
private int suspend;
SourceCodeAnalysisImpl(JShell proc) {
this.proc = proc;
this.ca = new CompletenessAnalyzer(proc);
int cpVersion = classpathVersion = 1;
INDEXER.submit(() -> refreshIndexes(cpVersion));
}
@Override
public CompletionInfo analyzeCompletion(String srcInput) {
MaskCommentsAndModifiers mcm = new MaskCommentsAndModifiers(srcInput, false);
String cleared = mcm.cleared();
String trimmedInput = Util.trimEnd(cleared);
if (trimmedInput.isEmpty()) {
// Just comment or empty
return new CompletionInfo(Completeness.EMPTY, srcInput.length(), srcInput, "");
}
CaInfo info = ca.scan(trimmedInput);
Completeness status = info.status;
int unitEndPos = info.unitEndPos;
if (unitEndPos > srcInput.length()) {
unitEndPos = srcInput.length();
}
int nonCommentNonWhiteLength = trimmedInput.length();
String src = srcInput.substring(0, unitEndPos);
switch (status) {
case COMPLETE:
if (unitEndPos == nonCommentNonWhiteLength) {
// The unit is the whole non-coment/white input plus semicolon
String compileSource = src
+ mcm.mask().substring(nonCommentNonWhiteLength);
proc.debug(DBG_COMPA, "Complete: %s\n", compileSource);
proc.debug(DBG_COMPA, " nothing remains.\n");
return new CompletionInfo(status, unitEndPos, compileSource, "");
} else {
String remain = srcInput.substring(unitEndPos);
proc.debug(DBG_COMPA, "Complete: %s\n", src);
proc.debug(DBG_COMPA, " remaining: %s\n", remain);
return new CompletionInfo(status, unitEndPos, src, remain);
}
case COMPLETE_WITH_SEMI:
// The unit is the whole non-coment/white input plus semicolon
String compileSource = src
+ ";"
+ mcm.mask().substring(nonCommentNonWhiteLength);
proc.debug(DBG_COMPA, "Complete with semi: %s\n", compileSource);
proc.debug(DBG_COMPA, " nothing remains.\n");
return new CompletionInfo(status, unitEndPos, compileSource, "");
case DEFINITELY_INCOMPLETE:
proc.debug(DBG_COMPA, "Incomplete: %s\n", srcInput);
return new CompletionInfo(status, unitEndPos, null, srcInput + '\n');
case CONSIDERED_INCOMPLETE:
proc.debug(DBG_COMPA, "Considered incomplete: %s\n", srcInput);
return new CompletionInfo(status, unitEndPos, null, srcInput + '\n');
case EMPTY:
proc.debug(DBG_COMPA, "Detected empty: %s\n", srcInput);
return new CompletionInfo(status, unitEndPos, srcInput, "");
case UNKNOWN:
proc.debug(DBG_COMPA, "Detected error: %s\n", srcInput);
return new CompletionInfo(status, unitEndPos, srcInput, "");
}
throw new InternalError();
}
private OuterWrap wrapInClass(Wrap guts) {
String imports = proc.maps.packageAndImportsExcept(null, null);
return OuterWrap.wrapInClass(proc.maps.packageName(), REPL_DOESNOTMATTER_CLASS_NAME, imports, "", guts);
}
private Tree.Kind guessKind(String code) {
ParseTask pt = proc.taskFactory.new ParseTask(code);
List units = pt.units();
if (units.isEmpty()) {
return Tree.Kind.BLOCK;
}
Tree unitTree = units.get(0);
proc.debug(DBG_COMPA, "Kind: %s -- %s\n", unitTree.getKind(), unitTree);
return unitTree.getKind();
}
//TODO: would be better handled through a lexer:
private final Pattern JAVA_IDENTIFIER = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*");
@Override
public List completionSuggestions(String code, int cursor, int[] anchor) {
suspendIndexing();
try {
return completionSuggestionsImpl(code, cursor, anchor);
} finally {
resumeIndexing();
}
}
private List completionSuggestionsImpl(String code, int cursor, int[] anchor) {
code = code.substring(0, cursor);
Matcher m = JAVA_IDENTIFIER.matcher(code);
String identifier = "";
while (m.find()) {
if (m.end() == code.length()) {
cursor = m.start();
code = code.substring(0, cursor);
identifier = m.group();
}
}
code = code.substring(0, cursor);
if (code.trim().isEmpty()) { //TODO: comment handling
code += ";";
}
OuterWrap codeWrap;
switch (guessKind(code)) {
case IMPORT:
codeWrap = OuterWrap.wrapImport(null, Wrap.importWrap(code + "any.any"));
break;
case METHOD:
codeWrap = wrapInClass(Wrap.classMemberWrap(code));
break;
default:
codeWrap = wrapInClass(Wrap.methodWrap(code));
break;
}
String requiredPrefix = identifier;
return computeSuggestions(codeWrap, cursor, anchor).stream()
.filter(s -> s.continuation.startsWith(requiredPrefix) && !s.continuation.equals(REPL_DOESNOTMATTER_CLASS_NAME))
.sorted(Comparator.comparing(s -> s.continuation))
.collect(collectingAndThen(toList(), Collections::unmodifiableList));
}
private List computeSuggestions(OuterWrap code, int cursor, int[] anchor) {
AnalyzeTask at = proc.taskFactory.new AnalyzeTask(code);
SourcePositions sp = at.trees().getSourcePositions();
CompilationUnitTree topLevel = at.firstCuTree();
List result = new ArrayList<>();
TreePath tp = pathFor(topLevel, sp, code.snippetIndexToWrapIndex(cursor));
if (tp != null) {
Scope scope = at.trees().getScope(tp);
Predicate accessibility = createAccessibilityFilter(at, tp);
Predicate smartTypeFilter;
Predicate smartFilter;
Iterable targetTypes = findTargetType(at, tp);
if (targetTypes != null) {
smartTypeFilter = el -> {
TypeMirror resultOf = resultTypeOf(el);
return Util.stream(targetTypes)
.anyMatch(targetType -> at.getTypes().isAssignable(resultOf, targetType));
};
smartFilter = IS_CLASS.negate()
.and(IS_INTERFACE.negate())
.and(IS_PACKAGE.negate())
.and(smartTypeFilter);
} else {
smartFilter = TRUE;
smartTypeFilter = TRUE;
}
switch (tp.getLeaf().getKind()) {
case MEMBER_SELECT: {
MemberSelectTree mst = (MemberSelectTree)tp.getLeaf();
if (mst.getIdentifier().contentEquals("*"))
break;
TreePath exprPath = new TreePath(tp, mst.getExpression());
TypeMirror site = at.trees().getTypeMirror(exprPath);
boolean staticOnly = isStaticContext(at, exprPath);
ImportTree it = findImport(tp);
boolean isImport = it != null;
List members = membersOf(at, site, staticOnly && !isImport);
Predicate filter = accessibility;
Function paren = DEFAULT_PAREN;
if (isNewClass(tp)) { // new xxx.|
Predicate constructorFilter = accessibility.and(IS_CONSTRUCTOR)
.and(el -> {
if (el.getEnclosingElement().getEnclosingElement().getKind() == ElementKind.CLASS) {
return el.getEnclosingElement().getModifiers().contains(Modifier.STATIC);
}
return true;
});
addElements(membersOf(at, members), constructorFilter, smartFilter, result);
filter = filter.and(IS_PACKAGE);
} else if (isThrowsClause(tp)) {
staticOnly = true;
filter = filter.and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));
smartFilter = IS_PACKAGE.negate().and(smartTypeFilter);
} else if (isImport) {
paren = NO_PAREN;
if (!it.isStatic()) {
filter = filter.and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));
}
} else {
filter = filter.and(IS_CONSTRUCTOR.negate());
}
filter = filter.and(staticOnly ? STATIC_ONLY : INSTANCE_ONLY);
addElements(members, filter, smartFilter, paren, result);
break;
}
case IDENTIFIER:
if (isNewClass(tp)) {
Function> listEnclosed =
el -> el.getKind() == ElementKind.PACKAGE ? Collections.singletonList(el)
: el.getEnclosedElements();
Predicate filter = accessibility.and(IS_CONSTRUCTOR.or(IS_PACKAGE));
NewClassTree newClassTree = (NewClassTree)tp.getParentPath().getLeaf();
ExpressionTree enclosingExpression = newClassTree.getEnclosingExpression();
if (enclosingExpression != null) { // expr.new IDENT|
TypeMirror site = at.trees().getTypeMirror(new TreePath(tp, enclosingExpression));
filter = filter.and(el -> el.getEnclosingElement().getKind() == ElementKind.CLASS && !el.getEnclosingElement().getModifiers().contains(Modifier.STATIC));
addElements(membersOf(at, membersOf(at, site, false)), filter, smartFilter, result);
} else {
addScopeElements(at, scope, listEnclosed, filter, smartFilter, result);
}
break;
}
if (isThrowsClause(tp)) {
Predicate accept = accessibility.and(STATIC_ONLY)
.and(IS_PACKAGE.or(IS_CLASS).or(IS_INTERFACE));
addScopeElements(at, scope, IDENTITY, accept, IS_PACKAGE.negate().and(smartTypeFilter), result);
break;
}
ImportTree it = findImport(tp);
if (it != null) {
addElements(membersOf(at, at.getElements().getPackageElement("").asType(), false), it.isStatic() ? STATIC_ONLY.and(accessibility) : accessibility, smartFilter, result);
}
break;
case ERRONEOUS:
case EMPTY_STATEMENT: {
boolean staticOnly = ReplResolve.isStatic(((JavacScope)scope).getEnv());
Predicate accept = accessibility.and(staticOnly ? STATIC_ONLY : TRUE);
addScopeElements(at, scope, IDENTITY, accept, smartFilter, result);
Tree parent = tp.getParentPath().getLeaf();
switch (parent.getKind()) {
case VARIABLE:
accept = ((VariableTree)parent).getType() == tp.getLeaf() ?
IS_VOID.negate() :
TRUE;
break;
case PARAMETERIZED_TYPE: // TODO: JEP 218: Generics over Primitive Types
case TYPE_PARAMETER:
case CLASS:
case INTERFACE:
case ENUM:
accept = FALSE;
break;
default:
accept = TRUE;
break;
}
addElements(primitivesOrVoid(at), accept, smartFilter, result);
break;
}
}
}
anchor[0] = cursor;
return result;
}
private boolean isStaticContext(AnalyzeTask at, TreePath path) {
switch (path.getLeaf().getKind()) {
case ARRAY_TYPE:
case PRIMITIVE_TYPE:
return true;
default:
Element selectEl = at.trees().getElement(path);
return selectEl != null && (selectEl.getKind().isClass() || selectEl.getKind().isInterface() || selectEl.getKind() == ElementKind.TYPE_PARAMETER) && selectEl.asType().getKind() != TypeKind.ERROR;
}
}
private TreePath pathFor(CompilationUnitTree topLevel, SourcePositions sp, int pos) {
TreePath[] deepest = new TreePath[1];
new TreePathScanner() {
@Override @DefinedBy(Api.COMPILER_TREE)
public Void scan(Tree tree, Void p) {
if (tree == null)
return null;
long start = sp.getStartPosition(topLevel, tree);
long end = sp.getEndPosition(topLevel, tree);
long prevEnd = deepest[0] != null ? sp.getEndPosition(topLevel, deepest[0].getLeaf()) : -1;
if (start <= pos && pos <= end &&
(start != end || prevEnd != end || deepest[0] == null ||
deepest[0].getParentPath().getLeaf() != getCurrentPath().getLeaf())) {
deepest[0] = new TreePath(getCurrentPath(), tree);
return super.scan(tree, p);
}
return null;
}
@Override @DefinedBy(Api.COMPILER_TREE)
public Void visitErroneous(ErroneousTree node, Void p) {
return scan(node.getErrorTrees(), null);
}
}.scan(topLevel, null);
return deepest[0];
}
private boolean isNewClass(TreePath tp) {
return tp.getParentPath() != null &&
tp.getParentPath().getLeaf().getKind() == Kind.NEW_CLASS &&
((NewClassTree) tp.getParentPath().getLeaf()).getIdentifier() == tp.getLeaf();
}
private boolean isThrowsClause(TreePath tp) {
Tree parent = tp.getParentPath().getLeaf();
return parent.getKind() == Kind.METHOD &&
((MethodTree)parent).getThrows().contains(tp.getLeaf());
}
private ImportTree findImport(TreePath tp) {
while (tp != null && tp.getLeaf().getKind() != Kind.IMPORT) {
tp = tp.getParentPath();
}
return tp != null ? (ImportTree)tp.getLeaf() : null;
}
private Predicate createAccessibilityFilter(AnalyzeTask at, TreePath tp) {
Scope scope = at.trees().getScope(tp);
return el -> {
switch (el.getKind()) {
case ANNOTATION_TYPE: case CLASS: case ENUM: case INTERFACE:
return at.trees().isAccessible(scope, (TypeElement) el);
case PACKAGE:
case EXCEPTION_PARAMETER: case PARAMETER: case LOCAL_VARIABLE: case RESOURCE_VARIABLE:
return true;
default:
TypeMirror type = el.getEnclosingElement().asType();
if (type.getKind() == TypeKind.DECLARED)
return at.trees().isAccessible(scope, el, (DeclaredType) type);
else
return true;
}
};
}
private final Predicate TRUE = el -> true;
private final Predicate FALSE = TRUE.negate();
private final Predicate IS_STATIC = el -> el.getModifiers().contains(Modifier.STATIC);
private final Predicate IS_CONSTRUCTOR = el -> el.getKind() == ElementKind.CONSTRUCTOR;
private final Predicate IS_METHOD = el -> el.getKind() == ElementKind.METHOD;
private final Predicate IS_PACKAGE = el -> el.getKind() == ElementKind.PACKAGE;
private final Predicate IS_CLASS = el -> el.getKind().isClass();
private final Predicate IS_INTERFACE = el -> el.getKind().isInterface();
private final Predicate IS_VOID = el -> el.asType().getKind() == TypeKind.VOID;
private final Predicate STATIC_ONLY = el -> {
ElementKind kind = el.getKind();
Element encl = el.getEnclosingElement();
ElementKind enclKind = encl != null ? encl.getKind() : ElementKind.OTHER;
return IS_STATIC.or(IS_PACKAGE).or(IS_CLASS).or(IS_INTERFACE).test(el) || IS_PACKAGE.test(encl) ||
(kind == ElementKind.TYPE_PARAMETER && !enclKind.isClass() && !enclKind.isInterface());
};
private final Predicate INSTANCE_ONLY = el -> {
Element encl = el.getEnclosingElement();
return IS_STATIC.or(IS_CLASS).or(IS_INTERFACE).negate().test(el) ||
IS_PACKAGE.test(encl);
};
private final Function> IDENTITY = el -> Collections.singletonList(el);
private final Function DEFAULT_PAREN = hasParams -> hasParams ? "(" : "()";
private final Function NO_PAREN = hasParams -> "";
private void addElements(Iterable elements, Predicate accept, Predicate smart, List result) {
addElements(elements, accept, smart, DEFAULT_PAREN, result);
}
private void addElements(Iterable elements, Predicate accept, Predicate smart, Function paren, List result) {
Set hasParams = Util.stream(elements)
.filter(accept)
.filter(IS_CONSTRUCTOR.or(IS_METHOD))
.filter(c -> !((ExecutableElement)c).getParameters().isEmpty())
.map(this::simpleName)
.collect(toSet());
for (Element c : elements) {
if (!accept.test(c))
continue;
String simpleName = simpleName(c);
if (c.getKind() == ElementKind.CONSTRUCTOR || c.getKind() == ElementKind.METHOD) {
simpleName += paren.apply(hasParams.contains(simpleName));
}
result.add(new Suggestion(simpleName, smart.test(c)));
}
}
private String simpleName(Element el) {
return el.getKind() == ElementKind.CONSTRUCTOR ? el.getEnclosingElement().getSimpleName().toString()
: el.getSimpleName().toString();
}
private List membersOf(AnalyzeTask at, TypeMirror site, boolean shouldGenerateDotClassItem) {
if (site == null)
return Collections.emptyList();
switch (site.getKind()) {
case DECLARED: {
TypeElement element = (TypeElement) at.getTypes().asElement(site);
List result = new ArrayList<>();
result.addAll(at.getElements().getAllMembers(element));
if (shouldGenerateDotClassItem) {
result.add(createDotClassSymbol(at, site));
}
result.removeIf(el -> el.getKind() == ElementKind.STATIC_INIT);
return result;
}
case ERROR: {
//try current qualified name as a package:
TypeElement typeElement = (TypeElement) at.getTypes().asElement(site);
Element enclosingElement = typeElement.getEnclosingElement();
String parentPackageName = enclosingElement instanceof QualifiedNameable ?
((QualifiedNameable)enclosingElement).getQualifiedName().toString() :
"";
Set packages = listPackages(at, parentPackageName);
return packages.stream()
.filter(p -> p.getQualifiedName().equals(typeElement.getQualifiedName()))
.findAny()
.map(p -> membersOf(at, p.asType(), false))
.orElse(Collections.emptyList());
}
case PACKAGE: {
String packageName = site.toString()/*XXX*/;
List result = new ArrayList<>();
result.addAll(getEnclosedElements(at.getElements().getPackageElement(packageName)));
result.addAll(listPackages(at, packageName));
return result;
}
case BOOLEAN: case BYTE: case SHORT: case CHAR:
case INT: case FLOAT: case LONG: case DOUBLE:
case VOID: {
return shouldGenerateDotClassItem ?
Collections.singletonList(createDotClassSymbol(at, site)) :
Collections.emptyList();
}
case ARRAY: {
List result = new ArrayList<>();
result.add(createArrayLengthSymbol(at, site));
if (shouldGenerateDotClassItem)
result.add(createDotClassSymbol(at, site));
return result;
}
default:
return Collections.emptyList();
}
}
private List membersOf(AnalyzeTask at, List elements) {
return elements.stream()
.flatMap(e -> membersOf(at, e.asType(), true).stream())
.collect(toList());
}
private List getEnclosedElements(PackageElement packageEl) {
if (packageEl == null) {
return Collections.emptyList();
}
//workaround for: JDK-8024687
while (true) {
try {
return packageEl.getEnclosedElements()
.stream()
.filter(el -> el.asType() != null)
.filter(el -> el.asType().getKind() != TypeKind.ERROR)
.collect(toList());
} catch (CompletionFailure cf) {
//ignore...
}
}
}
private List primitivesOrVoid(AnalyzeTask at) {
Types types = at.getTypes();
return Stream.of(
TypeKind.BOOLEAN, TypeKind.BYTE, TypeKind.CHAR,
TypeKind.DOUBLE, TypeKind.FLOAT, TypeKind.INT,
TypeKind.LONG, TypeKind.SHORT, TypeKind.VOID)
.map(tk -> (Type)(tk == TypeKind.VOID ? types.getNoType(tk) : types.getPrimitiveType(tk)))
.map(Type::asElement)
.collect(toList());
}
void classpathChanged() {
synchronized (currentIndexes) {
int cpVersion = ++classpathVersion;
INDEXER.submit(() -> refreshIndexes(cpVersion));
}
}
private Set listPackages(AnalyzeTask at, String enclosingPackage) {
synchronized (currentIndexes) {
return currentIndexes.values()
.stream()
.flatMap(idx -> idx.packages.stream())
.filter(p -> enclosingPackage.isEmpty() || p.startsWith(enclosingPackage + "."))
.map(p -> {
int dot = p.indexOf('.', enclosingPackage.length() + 1);
return dot == (-1) ? p : p.substring(0, dot);
})
.distinct()
.map(p -> createPackageElement(at, p))
.collect(Collectors.toSet());
}
}
private PackageElement createPackageElement(AnalyzeTask at, String packageName) {
Names names = Names.instance(at.getContext());
Symtab syms = Symtab.instance(at.getContext());
PackageElement existing = syms.enterPackage(names.fromString(packageName));
return existing;
}
private Element createArrayLengthSymbol(AnalyzeTask at, TypeMirror site) {
Name length = Names.instance(at.getContext()).length;
Type intType = Symtab.instance(at.getContext()).intType;
return new VarSymbol(Flags.PUBLIC | Flags.FINAL, length, intType, ((Type) site).tsym);
}
private Element createDotClassSymbol(AnalyzeTask at, TypeMirror site) {
Name _class = Names.instance(at.getContext())._class;
Type classType = Symtab.instance(at.getContext()).classType;
Type erasedSite = (Type)at.getTypes().erasure(site);
classType = new ClassType(classType.getEnclosingType(), com.sun.tools.javac.util.List.of(erasedSite), classType.asElement());
return new VarSymbol(Flags.PUBLIC | Flags.STATIC | Flags.FINAL, _class, classType, erasedSite.tsym);
}
private Iterable scopeContent(AnalyzeTask at, Scope scope, Function> elementConvertor) {
Iterable scopeIterable = () -> new Iterator() {
private Scope currentScope = scope;
@Override
public boolean hasNext() {
return currentScope != null;
}
@Override
public Scope next() {
if (!hasNext())
throw new NoSuchElementException();
try {
return currentScope;
} finally {
currentScope = currentScope.getEnclosingScope();
}
}
};
@SuppressWarnings("unchecked")
List result = Util.stream(scopeIterable)
.flatMap(s -> Util.stream((Iterable)s.getLocalElements()))
.flatMap(el -> Util.stream((Iterable)elementConvertor.apply(el)))
.collect(toCollection(ArrayList :: new));
result.addAll(listPackages(at, ""));
return result;
}
@SuppressWarnings("fallthrough")
private Iterable findTargetType(AnalyzeTask at, TreePath forPath) {
if (forPath.getParentPath() == null)
return null;
Tree current = forPath.getLeaf();
switch (forPath.getParentPath().getLeaf().getKind()) {
case ASSIGNMENT: {
AssignmentTree tree = (AssignmentTree) forPath.getParentPath().getLeaf();
if (tree.getExpression() == current)
return Collections.singletonList(at.trees().getTypeMirror(new TreePath(forPath.getParentPath(), tree.getVariable())));
break;
}
case VARIABLE: {
VariableTree tree = (VariableTree) forPath.getParentPath().getLeaf();
if (tree.getInitializer()== current)
return Collections.singletonList(at.trees().getTypeMirror(forPath.getParentPath()));
break;
}
case ERRONEOUS:
return findTargetType(at, forPath.getParentPath());
case NEW_CLASS: {
NewClassTree nct = (NewClassTree) forPath.getParentPath().getLeaf();
List actuals = computeActualInvocationTypes(at, nct.getArguments(), forPath);
if (actuals != null) {
Iterable> candidateConstructors = newClassCandidates(at, forPath.getParentPath());
return computeSmartTypesForExecutableType(at, candidateConstructors, actuals);
} else {
return findTargetType(at, forPath.getParentPath());
}
}
case METHOD:
if (!isThrowsClause(forPath)) {
break;
}
// fall through
case THROW:
return Collections.singletonList(at.getElements().getTypeElement("java.lang.Throwable").asType());
case METHOD_INVOCATION: {
MethodInvocationTree mit = (MethodInvocationTree) forPath.getParentPath().getLeaf();
List actuals = computeActualInvocationTypes(at, mit.getArguments(), forPath);
if (actuals == null)
return null;
Iterable> candidateMethods = methodCandidates(at, forPath.getParentPath());
return computeSmartTypesForExecutableType(at, candidateMethods, actuals);
}
}
return null;
}
private List computeActualInvocationTypes(AnalyzeTask at, List arguments, TreePath currentArgument) {
if (currentArgument == null)
return null;
int paramIndex = arguments.indexOf(currentArgument.getLeaf());
if (paramIndex == (-1))
return null;
List actuals = new ArrayList<>();
for (ExpressionTree arg : arguments.subList(0, paramIndex)) {
actuals.add(at.trees().getTypeMirror(new TreePath(currentArgument.getParentPath(), arg)));
}
return actuals;
}
private List> filterExecutableTypesByArguments(AnalyzeTask at, Iterable> candidateMethods, List precedingActualTypes) {
List> candidate = new ArrayList<>();
int paramIndex = precedingActualTypes.size();
OUTER:
for (Pair method : candidateMethods) {
boolean varargInvocation = paramIndex >= method.snd.getParameterTypes().size();
for (int i = 0; i < paramIndex; i++) {
TypeMirror actual = precedingActualTypes.get(i);
if (this.parameterType(method.fst, method.snd, i, !varargInvocation)
.noneMatch(formal -> at.getTypes().isAssignable(actual, formal))) {
continue OUTER;
}
}
candidate.add(method);
}
return candidate;
}
private Stream parameterType(ExecutableElement method, ExecutableType methodType, int paramIndex, boolean allowVarArgsArray) {
int paramCount = methodType.getParameterTypes().size();
if (paramIndex >= paramCount && !method.isVarArgs())
return Stream.empty();
if (paramIndex < paramCount - 1 || !method.isVarArgs())
return Stream.of(methodType.getParameterTypes().get(paramIndex));
TypeMirror varargType = methodType.getParameterTypes().get(paramCount - 1);
TypeMirror elemenType = ((ArrayType) varargType).getComponentType();
if (paramIndex >= paramCount || !allowVarArgsArray)
return Stream.of(elemenType);
return Stream.of(varargType, elemenType);
}
private List computeSmartTypesForExecutableType(AnalyzeTask at, Iterable> candidateMethods, List precedingActualTypes) {
List candidate = new ArrayList<>();
int paramIndex = precedingActualTypes.size();
this.filterExecutableTypesByArguments(at, candidateMethods, precedingActualTypes)
.stream()
.flatMap(method -> parameterType(method.fst, method.snd, paramIndex, true))
.forEach(candidate::add);
return candidate;
}
private TypeMirror resultTypeOf(Element el) {
//TODO: should reflect the type of site!
switch (el.getKind()) {
case METHOD:
return ((ExecutableElement) el).getReturnType();
case CONSTRUCTOR:
case INSTANCE_INIT: case STATIC_INIT: //TODO: should be filtered out
return el.getEnclosingElement().asType();
default:
return el.asType();
}
}
private void addScopeElements(AnalyzeTask at, Scope scope, Function> elementConvertor, Predicate filter, Predicate smartFilter, List result) {
addElements(scopeContent(at, scope, elementConvertor), filter, smartFilter, result);
}
private Iterable> methodCandidates(AnalyzeTask at, TreePath invocation) {
MethodInvocationTree mit = (MethodInvocationTree) invocation.getLeaf();
ExpressionTree select = mit.getMethodSelect();
List> result = new ArrayList<>();
Predicate accessibility = createAccessibilityFilter(at, invocation);
switch (select.getKind()) {
case MEMBER_SELECT:
MemberSelectTree mst = (MemberSelectTree) select;
TreePath tp = new TreePath(new TreePath(invocation, select), mst.getExpression());
TypeMirror site = at.trees().getTypeMirror(tp);
if (site == null || site.getKind() != TypeKind.DECLARED)
break;
Element siteEl = at.getTypes().asElement(site);
if (siteEl == null)
break;
if (isStaticContext(at, tp)) {
accessibility = accessibility.and(STATIC_ONLY);
}
for (ExecutableElement ee : ElementFilter.methodsIn(membersOf(at, siteEl.asType(), false))) {
if (ee.getSimpleName().contentEquals(mst.getIdentifier())) {
if (accessibility.test(ee)) {
result.add(Pair.of(ee, (ExecutableType) at.getTypes().asMemberOf((DeclaredType) site, ee)));
}
}
}
break;
case IDENTIFIER:
IdentifierTree it = (IdentifierTree) select;
for (ExecutableElement ee : ElementFilter.methodsIn(scopeContent(at, at.trees().getScope(invocation), IDENTITY))) {
if (ee.getSimpleName().contentEquals(it.getName())) {
if (accessibility.test(ee)) {
result.add(Pair.of(ee, (ExecutableType) ee.asType())); //XXX: proper site
}
}
}
break;
default:
break;
}
return result;
}
private Iterable> newClassCandidates(AnalyzeTask at, TreePath newClassPath) {
NewClassTree nct = (NewClassTree) newClassPath.getLeaf();
Element type = at.trees().getElement(new TreePath(newClassPath.getParentPath(), nct.getIdentifier()));
TypeMirror targetType = at.trees().getTypeMirror(newClassPath);
if (targetType == null || targetType.getKind() != TypeKind.DECLARED) {
Iterable targetTypes = findTargetType(at, newClassPath);
if (targetTypes == null)
targetTypes = Collections.emptyList();
targetType =
StreamSupport.stream(targetTypes.spliterator(), false)
.filter(t -> at.getTypes().asElement(t) == type)
.findAny()
.orElse(at.getTypes().erasure(type.asType()));
}
List> candidateConstructors = new ArrayList<>();
Predicate accessibility = createAccessibilityFilter(at, newClassPath);
if (targetType != null &&
targetType.getKind() == TypeKind.DECLARED &&
type != null &&
(type.getKind().isClass() || type.getKind().isInterface())) {
for (ExecutableElement constr : ElementFilter.constructorsIn(type.getEnclosedElements())) {
if (accessibility.test(constr)) {
ExecutableType constrType =
(ExecutableType) at.getTypes().asMemberOf((DeclaredType) targetType, constr);
candidateConstructors.add(Pair.of(constr, constrType));
}
}
}
return candidateConstructors;
}
@Override
public String documentation(String code, int cursor) {
suspendIndexing();
try {
return documentationImpl(code, cursor);
} finally {
resumeIndexing();
}
}
private String documentationImpl(String code, int cursor) {
code = code.substring(0, cursor);
if (code.trim().isEmpty()) { //TODO: comment handling
code += ";";
}
if (guessKind(code) == Kind.IMPORT)
return null;
OuterWrap codeWrap = wrapInClass(Wrap.methodWrap(code));
AnalyzeTask at = proc.taskFactory.new AnalyzeTask(codeWrap);
SourcePositions sp = at.trees().getSourcePositions();
CompilationUnitTree topLevel = at.firstCuTree();
TreePath tp = pathFor(topLevel, sp, codeWrap.snippetIndexToWrapIndex(cursor));
if (tp == null)
return null;
TreePath prevPath = null;
while (tp != null && tp.getLeaf().getKind() != Kind.METHOD_INVOCATION && tp.getLeaf().getKind() != Kind.NEW_CLASS) {
prevPath = tp;
tp = tp.getParentPath();
}
if (tp == null)
return null;
Iterable> candidates;
List arguments;
if (tp.getLeaf().getKind() == Kind.METHOD_INVOCATION) {
MethodInvocationTree mit = (MethodInvocationTree) tp.getLeaf();
candidates = methodCandidates(at, tp);
arguments = mit.getArguments();
} else {
NewClassTree nct = (NewClassTree) tp.getLeaf();
candidates = newClassCandidates(at, tp);
arguments = nct.getArguments();
}
if (!isEmptyArgumentsContext(arguments)) {
List actuals = computeActualInvocationTypes(at, arguments, prevPath);
List fullActuals = actuals != null ? actuals : Collections.emptyList();
candidates =
this.filterExecutableTypesByArguments(at, candidates, fullActuals)
.stream()
.filter(method -> parameterType(method.fst, method.snd, fullActuals.size(), true).findAny().isPresent())
.collect(Collectors.toList());
}
return Util.stream(candidates)
.map(method -> Util.expunge(element2String(method.fst)))
.collect(joining("\n"));
}
private boolean isEmptyArgumentsContext(List arguments) {
if (arguments.size() == 1) {
Tree firstArgument = arguments.get(0);
return firstArgument.getKind() == Kind.ERRONEOUS;
}
return false;
}
private String element2String(Element el) {
switch (el.getKind()) {
case ANNOTATION_TYPE: case CLASS: case ENUM: case INTERFACE:
return ((TypeElement) el).getQualifiedName().toString();
case FIELD:
return element2String(el.getEnclosingElement()) + "." + el.getSimpleName() + ":" + el.asType();
case ENUM_CONSTANT:
return element2String(el.getEnclosingElement()) + "." + el.getSimpleName();
case EXCEPTION_PARAMETER: case LOCAL_VARIABLE: case PARAMETER: case RESOURCE_VARIABLE:
return el.getSimpleName() + ":" + el.asType();
case CONSTRUCTOR: case METHOD:
StringBuilder header = new StringBuilder();
header.append(element2String(el.getEnclosingElement()));
if (el.getKind() == ElementKind.METHOD) {
header.append(".");
header.append(el.getSimpleName());
}
header.append("(");
String sep = "";
ExecutableElement method = (ExecutableElement) el;
for (Iterator i = method.getParameters().iterator(); i.hasNext();) {
VariableElement p = i.next();
header.append(sep);
if (!i.hasNext() && method.isVarArgs()) {
header.append(unwrapArrayType(p.asType()));
header.append("...");
} else {
header.append(p.asType());
}
header.append(" ");
header.append(p.getSimpleName());
sep = ", ";
}
header.append(")");
return header.toString();
default:
return el.toString();
}
}
private TypeMirror unwrapArrayType(TypeMirror arrayType) {
if (arrayType.getKind() == TypeKind.ARRAY) {
return ((ArrayType)arrayType).getComponentType();
}
return arrayType;
}
@Override
public String analyzeType(String code, int cursor) {
code = code.substring(0, cursor);
CompletionInfo completionInfo = analyzeCompletion(code);
if (!completionInfo.completeness.isComplete)
return null;
if (completionInfo.completeness == Completeness.COMPLETE_WITH_SEMI) {
code += ";";
}
OuterWrap codeWrap;
switch (guessKind(code)) {
case IMPORT: case METHOD: case CLASS: case ENUM:
case INTERFACE: case ANNOTATION_TYPE: case VARIABLE:
return null;
default:
codeWrap = wrapInClass(Wrap.methodWrap(code));
break;
}
AnalyzeTask at = proc.taskFactory.new AnalyzeTask(codeWrap);
SourcePositions sp = at.trees().getSourcePositions();
CompilationUnitTree topLevel = at.firstCuTree();
int pos = codeWrap.snippetIndexToWrapIndex(code.length());
TreePath tp = pathFor(topLevel, sp, pos);
while (ExpressionTree.class.isAssignableFrom(tp.getParentPath().getLeaf().getKind().asInterface()) &&
tp.getParentPath().getLeaf().getKind() != Kind.ERRONEOUS &&
tp.getParentPath().getParentPath() != null)
tp = tp.getParentPath();
TypeMirror type = at.trees().getTypeMirror(tp);
if (type == null)
return null;
switch (type.getKind()) {
case ERROR: case NONE: case OTHER:
case PACKAGE: case VOID:
return null; //not usable
case NULL:
type = at.getElements().getTypeElement("java.lang.Object").asType();
break;
}
return TreeDissector.printType(at, proc, type);
}
@Override
public QualifiedNames listQualifiedNames(String code, int cursor) {
code = code.substring(0, cursor);
if (code.trim().isEmpty()) {
return new QualifiedNames(Collections.emptyList(), -1, true, false);
}
OuterWrap codeWrap;
switch (guessKind(code)) {
case IMPORT:
return new QualifiedNames(Collections.emptyList(), -1, true, false);
case METHOD:
codeWrap = wrapInClass(Wrap.classMemberWrap(code));
break;
default:
codeWrap = wrapInClass(Wrap.methodWrap(code));
break;
}
AnalyzeTask at = proc.taskFactory.new AnalyzeTask(codeWrap);
SourcePositions sp = at.trees().getSourcePositions();
CompilationUnitTree topLevel = at.firstCuTree();
TreePath tp = pathFor(topLevel, sp, codeWrap.snippetIndexToWrapIndex(code.length()));
if (tp.getLeaf().getKind() != Kind.IDENTIFIER) {
return new QualifiedNames(Collections.emptyList(), -1, true, false);
}
Scope scope = at.trees().getScope(tp);
TypeMirror type = at.trees().getTypeMirror(tp);
Element el = at.trees().getElement(tp);
boolean erroneous = (type.getKind() == TypeKind.ERROR && el.getKind() == ElementKind.CLASS) ||
(el.getKind() == ElementKind.PACKAGE && el.getEnclosedElements().isEmpty());
String simpleName = ((IdentifierTree) tp.getLeaf()).getName().toString();
boolean upToDate;
List result;
synchronized (currentIndexes) {
upToDate = classpathVersion == indexVersion;
result = currentIndexes.values()
.stream()
.flatMap(idx -> idx.classSimpleName2FQN.getOrDefault(simpleName,
Collections.emptyList()).stream())
.distinct()
.filter(fqn -> isAccessible(at, scope, fqn))
.sorted()
.collect(Collectors.toList());
}
return new QualifiedNames(result, simpleName.length(), upToDate, !erroneous);
}
private boolean isAccessible(AnalyzeTask at, Scope scope, String fqn) {
TypeElement type = at.getElements().getTypeElement(fqn);
if (type == null)
return false;
return at.trees().isAccessible(scope, type);
}
//--------------------
// classpath indexing:
//--------------------
//the indexing can be suspended when a more important task is running:
private void waitIndexingNotSuspended() {
boolean suspendedNotified = false;
synchronized (suspendLock) {
while (suspend > 0) {
if (!suspendedNotified) {
suspendedNotified = true;
}
try {
suspendLock.wait();
} catch (InterruptedException ex) {
}
}
}
}
public void suspendIndexing() {
synchronized (suspendLock) {
suspend++;
}
}
public void resumeIndexing() {
synchronized (suspendLock) {
if (--suspend == 0) {
suspendLock.notifyAll();
}
}
}
//update indexes, either initially or after a classpath change:
private void refreshIndexes(int version) {
try {
Collection paths = new ArrayList<>();
MemoryFileManager fm = proc.taskFactory.fileManager();
appendPaths(fm, StandardLocation.PLATFORM_CLASS_PATH, paths);
appendPaths(fm, StandardLocation.CLASS_PATH, paths);
appendPaths(fm, StandardLocation.SOURCE_PATH, paths);
Map newIndexes = new HashMap<>();
//setup existing/last known data:
for (Path p : paths) {
ClassIndex index = PATH_TO_INDEX.get(p);
if (index != null) {
newIndexes.put(p, index);
}
}
synchronized (currentIndexes) {
//temporary setting old data:
currentIndexes.clear();
currentIndexes.putAll(newIndexes);
}
//update/compute the indexes if needed:
for (Path p : paths) {
waitIndexingNotSuspended();
ClassIndex index = indexForPath(p);
newIndexes.put(p, index);
}
synchronized (currentIndexes) {
currentIndexes.clear();
currentIndexes.putAll(newIndexes);
}
} catch (Exception ex) {
proc.debug(ex, "SourceCodeAnalysisImpl.refreshIndexes(" + version + ")");
} finally {
synchronized (currentIndexes) {
indexVersion = version;
}
}
}
private void appendPaths(MemoryFileManager fm, Location loc, Collection paths) {
Iterable locationPaths = fm.getLocationAsPaths(loc);
if (locationPaths == null)
return ;
for (Path path : locationPaths) {
if (".".equals(path.toString())) {
//skip CWD
continue;
}
paths.add(path);
}
}
//create/update index a given JavaFileManager entry (which may be a JDK installation, a jar/zip file or a directory):
//if an index exists for the given entry, the existing index is kept unless the timestamp is modified
private ClassIndex indexForPath(Path path) {
if (isJRTMarkerFile(path)) {
FileSystem jrtfs = FileSystems.getFileSystem(URI.create("jrt:/"));
Path modules = jrtfs.getPath("modules");
return PATH_TO_INDEX.compute(path, (p, index) -> {
try {
long lastModified = Files.getLastModifiedTime(modules).toMillis();
if (index == null || index.timestamp != lastModified) {
try (DirectoryStream stream = Files.newDirectoryStream(modules)) {
index = doIndex(lastModified, path, stream);
}
}
return index;
} catch (IOException ex) {
proc.debug(ex, "SourceCodeAnalysisImpl.indexesForPath(" + path.toString() + ")");
return new ClassIndex(-1, path, Collections.emptySet(), Collections.emptyMap());
}
});
} else if (!Files.isDirectory(path)) {
if (Files.exists(path)) {
return PATH_TO_INDEX.compute(path, (p, index) -> {
try {
long lastModified = Files.getLastModifiedTime(p).toMillis();
if (index == null || index.timestamp != lastModified) {
ClassLoader cl = SourceCodeAnalysisImpl.class.getClassLoader();
try (FileSystem zip = FileSystems.newFileSystem(path, cl)) {
index = doIndex(lastModified, path, zip.getRootDirectories());
}
}
return index;
} catch (IOException ex) {
proc.debug(ex, "SourceCodeAnalysisImpl.indexesForPath(" + path.toString() + ")");
return new ClassIndex(-1, path, Collections.emptySet(), Collections.emptyMap());
}
});
} else {
return new ClassIndex(-1, path, Collections.emptySet(), Collections.emptyMap());
}
} else {
return PATH_TO_INDEX.compute(path, (p, index) -> {
//no persistence for directories, as we cannot check timestamps:
if (index == null) {
index = doIndex(-1, path, Arrays.asList(p));
}
return index;
});
}
}
static boolean isJRTMarkerFile(Path path) {
return path.equals(Paths.get("JRT_MARKER_FILE"));
}
//create an index based on the content of the given dirs; the original JavaFileManager entry is originalPath.
private ClassIndex doIndex(long timestamp, Path originalPath, Iterable dirs) {
Set packages = new HashSet<>();
Map> classSimpleName2FQN = new HashMap<>();
for (Path d : dirs) {
try {
Files.walkFileTree(d, new FileVisitor() {
int depth;
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
waitIndexingNotSuspended();
if (depth++ == 0)
return FileVisitResult.CONTINUE;
String dirName = dir.getFileName().toString();
String sep = dir.getFileSystem().getSeparator();
dirName = dirName.endsWith(sep) ? dirName.substring(0, dirName.length() - sep.length())
: dirName;
if (SourceVersion.isIdentifier(dirName))
return FileVisitResult.CONTINUE;
return FileVisitResult.SKIP_SUBTREE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
waitIndexingNotSuspended();
if (file.getFileName().toString().endsWith(".class")) {
String relativePath = d.relativize(file).toString();
String binaryName = relativePath.substring(0, relativePath.length() - 6).replace('/', '.');
int packageDot = binaryName.lastIndexOf('.');
if (packageDot > (-1)) {
packages.add(binaryName.substring(0, packageDot));
}
String typeName = binaryName.replace('$', '.');
addClassName2Map(classSimpleName2FQN, typeName);
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
depth--;
return FileVisitResult.CONTINUE;
}
});
} catch (IOException ex) {
proc.debug(ex, "doIndex(" + d.toString() + ")");
}
}
return new ClassIndex(timestamp, originalPath, packages, classSimpleName2FQN);
}
private static void addClassName2Map(Map> classSimpleName2FQN, String typeName) {
int simpleNameDot = typeName.lastIndexOf('.');
classSimpleName2FQN.computeIfAbsent(typeName.substring(simpleNameDot + 1), n -> new LinkedHashSet<>())
.add(typeName);
}
//holder for indexed data about a given path
public static final class ClassIndex {
public final long timestamp;
public final Path forPath;
public final Set packages;
public final Map> classSimpleName2FQN;
public ClassIndex(long timestamp, Path forPath, Set packages, Map> classSimpleName2FQN) {
this.timestamp = timestamp;
this.forPath = forPath;
this.packages = packages;
this.classSimpleName2FQN = classSimpleName2FQN;
}
}
//for tests, to be able to wait until the indexing finishes:
public void waitBackgroundTaskFinished() throws Exception {
boolean upToDate;
synchronized (currentIndexes) {
upToDate = classpathVersion == indexVersion;
}
while (!upToDate) {
INDEXER.submit(() -> {}).get();
synchronized (currentIndexes) {
upToDate = classpathVersion == indexVersion;
}
}
}
}