@Override public void visit(Name n, Void arg) { out.println("Name: " + (extended ? n : n.getIdentifier())); super.visit(n, arg); }
private static ImportDeclaration importDeclaration(String name) { return new ImportDeclaration(new Name(name), false, 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) { String qName = this.wrappedNode.getPackageDeclaration().get().getName().toString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref.isSolved()) {
private boolean isGenerated(BodyDeclaration<?> node) { for (AnnotationExpr annotation : node.getAnnotations()) { if (annotation.getName().toString().equals("Generated")) { return true; } } return false; }
@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; }
/** {@inheritDoc} */ @Override public void visit(ImportDeclaration n, ClassBuilder builder) { super.visit(n, builder); String typeName = n.getName().getIdentifier(); String packageName = n.getName().getQualifier().map(Name::asString).orElse(""); imports.put(typeName, packageName); }
private String qName(Name name) { if (name.getQualifier().isPresent()) { return qName(name.getQualifier().get()) + "." + name.getId(); } else { return name.getId(); } }
@Override public boolean hasDirectlyAnnotation(String canonicalName) { for (AnnotationExpr annotationExpr : wrappedNode.getAnnotations()) { if (solveType(annotationExpr.getName().getId(), typeSolver).getCorrespondingDeclaration().getQualifiedName().equals(canonicalName)) { return true; } } return false; }
private static boolean isSyntacticallyAPackageName(Node name) { // A name is syntactically classified as a PackageName in these contexts: // // 1. To the right of exports or opens in a module declaration if (whenParentIs(ModuleExportsDirective.class, name, (p, c) -> p.getName() == name)) { return true; } if (whenParentIs(ModuleOpensDirective.class, name, (p, c) -> p.getName() == name)) { return true; } // 2. To the left of the "." in a qualified PackageName if (whenParentIs(Name.class, name, (p, c) -> p.getQualifier().isPresent() && p.getQualifier().get() == name && isSyntacticallyAPackageName(p))) { return true; } return false; }
private String parseModuleName(final Path moduleInfoJavaPath, final JavaParser parser) { try { if (! exists(moduleInfoJavaPath)) { return null; } final ParseResult<CompilationUnit> result = parser.parse(COMPILATION_UNIT, provider(moduleInfoJavaPath)); if (result.isSuccessful()) { return result.getResult().get().getModule().map(module -> module.getName().asString()).orElseThrow(GradleException::new); } throw new ParseProblemException(result.getProblems()); } catch (final IOException ex) { throw new GradleException("Couldn't parse Java module name from " + moduleInfoJavaPath, ex); } }
String qName = this.wrappedNode.getPackageDeclaration().get().getName().toString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref != null && ref.isSolved()) { 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) {
@Override public Void visit(PackageDeclaration n, Map<AccessibleObject, String[]> arg) { packageName = n.getName().toString(); return super.visit(n, arg); }
private String qName(Name name) { if (name.getQualifier().isPresent()) { return qName(name.getQualifier().get()) + "." + name.getId(); } else { return name.getId(); } }
@Override public boolean hasDirectlyAnnotation(String canonicalName) { for (AnnotationExpr annotationExpr : wrappedNode.getAnnotations()) { if (solveType(annotationExpr.getName().getId(), typeSolver).getCorrespondingDeclaration().getQualifiedName().equals(canonicalName)) { return true; } } return false; }
throw new IllegalArgumentException("We cannot understand the role of a name if it has no parent"); if (whenParentIs(Name.class, name, (p, c) -> p.getQualifier().isPresent() && p.getQualifier().get() == c)) { return classifyRole(name.getParentNode().get());
/** * Return the string representation of the name */ public static String nameAsString(Node name) { if (!isAName(name)) { throw new IllegalArgumentException("A name was expected"); } if (name instanceof Name) { return ((Name) name).asString(); } else if (name instanceof SimpleName) { return ((SimpleName) name).getIdentifier(); } else if (name instanceof ClassOrInterfaceType) { return ((ClassOrInterfaceType) name).asString(); } else if (name instanceof FieldAccessExpr) { FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) name; if (isAName(fieldAccessExpr.getScope())) { return nameAsString(fieldAccessExpr.getScope()) + "." + nameAsString(fieldAccessExpr.getName()); } else { throw new IllegalArgumentException(); } } else if (name instanceof NameExpr) { return ((NameExpr) name).getNameAsString(); } else { throw new UnsupportedOperationException("Unknown type of name found: " + name + " (" + name.getClass().getCanonicalName() + ")"); } }
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) { String qName = this.wrappedNode.getPackageDeclaration().get().getName().toString() + "." + name; SymbolReference<ResolvedReferenceTypeDeclaration> ref = typeSolver.tryToSolveType(qName); if (ref.isSolved()) {
@Override public void visit(PackageDeclaration n, Object arg) { this.pkg = n.getName().toString(); super.visit(n, arg); }
private MemberParameterTag createMemberParamTag(JavadocDescription javadocDescription, Stream<AnnotationExpr> annotationStream) { Map<String, String> annotations = annotationStream .filter(Expression::isSingleMemberAnnotationExpr) .collect(Collectors.toMap(a -> a.getName().getIdentifier(), this::createMemberParamValue)); return new MemberParameterTag(javadocDescription.toText(), annotations); }
private String qName(Name name) { if (name.getQualifier().isPresent()) { return qName(name.getQualifier().get()) + "." + name.getId(); } else { return name.getId(); } }