private static ImportDeclaration importDeclaration(String name) { return new ImportDeclaration(new Name(name), false, false); }
private static void organiseImports(CompilationUnit cu) { List<ImportDeclaration> importDecls = new ArrayList<>(); for (ImportDeclaration importDeclaration : cu.getImports()) { String name = importDeclaration.getNameAsString(); if (name.startsWith("org.jctools.util.Unsafe")) { continue; importDeclaration.setName(name.replace("org.jctools.queues.LinkedArrayQueueUtil", "org.jctools.queues.atomic.LinkedAtomicArrayQueueUtil"));
@Override public boolean doIsEquals(ImportDeclaration first, ImportDeclaration second) { if(!isEqualsUseMerger(first.getName(),second.getName())) return false; if(first.isStatic() != second.isStatic()) return false; if(first.isAsterisk() != second.isAsterisk()) return false; return true; } }
private boolean hasImport(List<ImportDeclaration> imports, String importName) { for (ImportDeclaration i : imports) { if (importName.equals(i.getName().toString())) { return true; } } return false; } }
if (!importDecl.isAsterisk()) { String qName = importDecl.getNameAsString(); boolean defaultPackage = !importDecl.getName().getQualifier().isPresent(); boolean found = !defaultPackage && importDecl.getName().getIdentifier().equals(name); if (!found) { if (prefix != null) { if (importDecl.isAsterisk()) { String qName = importDecl.getNameAsString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref.isSolved()) {
@Override public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { for (ImportDeclaration importDecl : wrappedNode.getImports()) { if(importDecl.isStatic()){ if(importDecl.isAsterisk()){ String importString = importDecl.getNameAsString(); String qName = importDecl.getNameAsString();
@Override public ImportDeclaration doMerge(ImportDeclaration first, ImportDeclaration second) { ImportDeclaration id = new ImportDeclaration(); id.setName(mergeSingle(first.getName(),second.getName())); id.setAsterisk(first.isAsterisk()); id.setStatic(first.isStatic()); return id; }
@Nonnull @Override protected Iterable<String> calculatePrefixes(@Nonnull Qualifier<?> topQualifier) { ArrayList<String> asteriskImports = newArrayList(); CompilationUnit compilationUnit = Nodes.getCompilationUnit(topQualifier.getNode()); for (ImportDeclaration importDeclaration : emptyIfNull(compilationUnit.getImports()).filter(isAsterisk())) { StringBuilder buffy = prepend(importDeclaration.getName(), new StringBuilder()); buffy.append(importDeclaration.isStatic() ? '$' : '.'); asteriskImports.add(buffy.toString()); } return asteriskImports; }
@Override public void visit(ImportDeclaration n, Void arg) { out.println("ImportDeclaration: " + (extended ? n : n.getNameAsString())); super.visit(n, arg); }
@Override @SuppressWarnings("ConstantConditions") public boolean apply(@Nullable ImportDeclaration input) { return checkNotNull(input).isAsterisk(); } };
@Override @SuppressWarnings("ConstantConditions") public boolean apply(@Nullable ImportDeclaration input) { return checkNotNull(input).isStatic(); } };
@Nullable @Override public String apply(@Nullable ImportDeclaration input) { if (input == null) { return null; } NameExpr name = input.getName(); if (input.isStatic() && !input.isAsterisk()) { name = QualifiedNameExpr.class.cast(name).getQualifier(); } return name.toString(); } };
private boolean hasImport(List<ImportDeclaration> imports, String importName) { for (ImportDeclaration i : imports) { if (importName.equals(i.getName().toString())) { return true; } } return false; } }
if (!importDecl.isAsterisk()) { String qName = importDecl.getNameAsString(); boolean defaultPackage = !importDecl.getName().getQualifier().isPresent(); boolean found = !defaultPackage && importDecl.getName().getIdentifier().equals(name); if (!found) { if (prefix != null) { if (importDecl.isAsterisk()) { String qName = importDecl.getNameAsString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref.isSolved()) {
@Override public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { for (ImportDeclaration importDecl : wrappedNode.getImports()) { if(importDecl.isStatic()){ if(importDecl.isAsterisk()){ String importString = importDecl.getNameAsString(); String qName = importDecl.getNameAsString();
@Nullable @Override protected String calculatePrefix(@Nonnull Qualifier<?> topQualifier) { String firstQualifier = topQualifier.getFirstQualifier().getName(); CompilationUnit compilationUnit = Nodes.getCompilationUnit(topQualifier.getNode()); ImportDeclaration importDeclaration = getOnlyElement(emptyIfNull(compilationUnit.getImports()).filter( and(not(isAsterisk()), refersTo(firstQualifier))), null); if (importDeclaration == null) { return null; } StringBuilder buffy = prepend(importDeclaration.getName(), new StringBuilder()); int beginIndex = buffy.length() - firstQualifier.length(); return beginIndex == 0 ? "" : buffy.replace(beginIndex - 1, buffy.length(), importDeclaration.isStatic() ? "$" : ".").toString(); }
private static void organiseImports(CompilationUnit cu) { List<ImportDeclaration> importDecls = new ArrayList<>(); for (ImportDeclaration importDeclaration : cu.getImports()) { if (importDeclaration.getNameAsString().startsWith("org.jctools.util.Unsafe")) { continue; } importDecls.add(importDeclaration); } cu.getImports().clear(); for (ImportDeclaration importDecl : importDecls) { cu.addImport(importDecl); } cu.addImport(importDeclaration("java.util.concurrent.atomic.AtomicLongFieldUpdater")); cu.addImport(importDeclaration("java.util.concurrent.atomic.AtomicReferenceArray")); cu.addImport(importDeclaration("java.util.concurrent.atomic.AtomicLongArray")); }
@Override public List<ResolvedFieldDeclaration> fieldsExposedToChild(Node child) { List<ResolvedFieldDeclaration> res = new LinkedList<>(); // Consider the static imports for static fields for (ImportDeclaration importDeclaration : wrappedNode.getImports()) { if (importDeclaration.isStatic()) { Name typeNameAsNode = importDeclaration.isAsterisk() ? importDeclaration.getName() : importDeclaration.getName().getQualifier().get(); String typeName = typeNameAsNode.asString(); ResolvedReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(typeName); res.addAll(typeDeclaration.getAllFields().stream() .filter(f -> f.isStatic()) .filter(f -> importDeclaration.isAsterisk() || importDeclaration.getName().getIdentifier().equals(f.getName())) .collect(Collectors.toList())); } } return res; }
if (!importDecl.isAsterisk()) { String qName = importDecl.getNameAsString(); boolean defaultPackage = !importDecl.getName().getQualifier().isPresent(); boolean found = !defaultPackage && importDecl.getName().getIdentifier().equals(name); if (!found) { if (prefix != null) { if (importDecl.isAsterisk()) { String qName = importDecl.getNameAsString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref != null && ref.isSolved()) {