private String name(final FieldAccessExpr n) { LinkedList<String> name = new LinkedList<>(); Expression it = n.getScope(); while (it instanceof FieldAccessExpr) { name.addFirst(((FieldAccessExpr) it).getField()); it = ((FieldAccessExpr) it).getScope(); } name.addFirst(it.toStringWithoutComments()); return name.stream().collect(Collectors.joining(".")); }
public SymbolReference<ResolvedFieldDeclaration> solveField(String name, TypeSolver typeSolver) { Collection<ResolvedReferenceTypeDeclaration> rrtds = findTypeDeclarations(Optional.of(wrappedNode.getScope()), typeSolver); for (ResolvedReferenceTypeDeclaration rrtd : rrtds) { try { return SymbolReference.solved(rrtd.getField(wrappedNode.getName().getId())); } catch (Throwable t) { } } return SymbolReference.unsolved(ResolvedFieldDeclaration.class); } }
if (node.getScope() instanceof NameExpr || node.getScope() instanceof FieldAccessExpr) { Expression staticValue = node.getScope(); SymbolReference<ResolvedTypeDeclaration> typeAccessedStatically = JavaParserFactory.getContext(node, typeSolver).solveType(staticValue.toString(), typeSolver); if (typeAccessedStatically.isSolved()) { typeAccessedStatically.getCorrespondingDeclaration().asReferenceType(), node); } else if (node.getScope()instanceof ThisExpr){ SymbolReference<ResolvedTypeDeclaration> solve = facade.solve((ThisExpr) node.getScope()); } else if (node.getScope().toString().indexOf('.') > 0) { SymbolReference<ResolvedReferenceTypeDeclaration> sr = typeSolver.tryToSolveType(node.getScope().toString()); if (sr.isSolved()) { return solveDotExpressionType(sr.getCorrespondingDeclaration(), node); value = new SymbolSolver(typeSolver).solveSymbolAsValue(node.getField().getId(), node); } catch (UnsolvedSymbolException use) { SymbolReference<ResolvedReferenceTypeDeclaration> sref = typeSolver.tryToSolveType(node.toString()); if (sref.isSolved()) { return new ReferenceTypeImpl(sref.getCorrespondingDeclaration(), typeSolver); return value.get().getType(); } else { throw new UnsolvedSymbolException(node.getField().getId());
@Override public FieldAccessExpr doMerge(FieldAccessExpr first, FieldAccessExpr second) { FieldAccessExpr fae = new FieldAccessExpr(); fae.setFieldExpr(mergeSingle(first.getFieldExpr(),second.getFieldExpr())); fae.setScope(mergeSingle(first.getScope(),second.getScope())); fae.setTypeArgs(mergeCollections(first.getTypeArgs(),second.getTypeArgs())); return fae; }
@Nonnull @Override protected String getName(@Nonnull FieldAccessExpr reference) { return reference.getField(); }
@Override public boolean doIsEquals(FieldAccessExpr first, FieldAccessExpr second) { if(!isEqualsUseMerger(first.getScope(), second.getScope())) return false; if(!isEqualsUseMerger(first.getTypeArgs(),second.getTypeArgs())) return false; if(!isEqualsUseMerger(first.getFieldExpr(),second.getFieldExpr())) return false; return true; } }
if (node.getScope() instanceof NameExpr || node.getScope() instanceof FieldAccessExpr) { Expression staticValue = node.getScope(); SymbolReference<ResolvedTypeDeclaration> typeAccessedStatically = JavaParserFactory.getContext(node, typeSolver).solveType(staticValue.toString()); if (typeAccessedStatically.isSolved()) { typeAccessedStatically.getCorrespondingDeclaration().asReferenceType(), node); } else if (node.getScope() instanceof ThisExpr) { SymbolReference<ResolvedTypeDeclaration> solve = facade.solve((ThisExpr) node.getScope()); } else if (node.getScope().toString().indexOf('.') > 0) { SymbolReference<ResolvedReferenceTypeDeclaration> sr = typeSolver.tryToSolveType(node.getScope().toString()); if (sr.isSolved()) { return solveDotExpressionType(sr.getCorrespondingDeclaration(), node); value = new SymbolSolver(typeSolver).solveSymbolAsValue(node.getName().getId(), node); } catch (com.github.javaparser.resolution.UnsolvedSymbolException use) { SymbolReference<ResolvedReferenceTypeDeclaration> sref = typeSolver.tryToSolveType(node.toString()); if (sref.isSolved()) { return new ReferenceTypeImpl(sref.getCorrespondingDeclaration(), typeSolver); return value.get().getType(); throw new com.github.javaparser.resolution.UnsolvedSymbolException(node.getName().getId());
@Override public String visit(FieldAccessExpr n, String arg) { return visit(n.getFieldExpr(), findClassNamed(n.getScope(), getClassDeclarationOf(n))); }
Expression e; Optional<Expression> oe; String nname = n.getNameAsString(); ((oe = n.getScope()).isPresent()) && ((e = getUnenclosedExpr(oe.get())) instanceof CastExpr) && ("jcasType".equals(getName(((CastExpr)e).getExpression())))) {
private MethodDeclaration getterDeclaration(EntityField field) { MethodDeclaration decl = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.createReferenceType(field.getType().getSimpleName(), 0), "get" + CaseConverter.pascalCase(field.getName())); BlockStmt body = new BlockStmt(); body.setStmts( Collections.singletonList( new ReturnStmt( new FieldAccessExpr(new ThisExpr(), field.getName())))); decl.setBody(body); return decl; }
private static Node getRightMostName(Node node) { if (node instanceof FieldAccessExpr) { FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) node; return fieldAccessExpr.getName(); } throw new UnsupportedOperationException(node.getClass().getCanonicalName()); }
if (this.solveType(scopeName.toString()).isSolved()) { return Collections.emptyList();
private static String getFullQualifier(FieldAccessExpr reference) { StringBuilder buffy = new StringBuilder(reference.getField()); for (FieldAccessExpr loop = reference; loop != null; ) { Expression scope = loop.getScope(); final String qualifier; if (NameExpr.class.isInstance(scope)) { loop = null; qualifier = NameExpr.class.cast(scope).getName(); } else { loop = FieldAccessExpr.class.cast(scope); qualifier = loop.getField(); } buffy.insert(0, '.'); buffy.insert(0, qualifier); } return buffy.toString(); }
/** * 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 (node.getScope() instanceof NameExpr || node.getScope() instanceof FieldAccessExpr) { Expression staticValue = node.getScope(); SymbolReference<ResolvedTypeDeclaration> typeAccessedStatically = JavaParserFactory.getContext(node, typeSolver).solveType(staticValue.toString(), typeSolver); if (typeAccessedStatically.isSolved()) { typeAccessedStatically.getCorrespondingDeclaration().asReferenceType(), node); } else if (node.getScope()instanceof ThisExpr){ SymbolReference<ResolvedTypeDeclaration> solve = facade.solve((ThisExpr) node.getScope()); } else if (node.getScope().toString().indexOf('.') > 0) { SymbolReference<ResolvedReferenceTypeDeclaration> sr = typeSolver.tryToSolveType(node.getScope().toString()); if (sr.isSolved()) { return solveDotExpressionType(sr.getCorrespondingDeclaration(), node); value = new SymbolSolver(typeSolver).solveSymbolAsValue(node.getField().getId(), node); } catch (UnsolvedSymbolException use) { SymbolReference<ResolvedReferenceTypeDeclaration> sref = typeSolver.tryToSolveType(node.toString()); if (sref.isSolved()) { return new ReferenceTypeImpl(sref.getCorrespondingDeclaration(), typeSolver); return value.get().getType(); } else { throw new UnsolvedSymbolException(node.getField().getId());
@SuppressWarnings({"rawtypes", "unchecked" }) @Override public Object visit(final FieldAccessExpr n, final Context ctx) { String name = name(n); Type type = ctx.resolveType(n, name) .orElseThrow(() -> new IllegalArgumentException("Type not found " + name)); if (type instanceof Class) { Class etype = (Class) type; if (etype.isEnum()) { return Enum.valueOf(etype, n.getField()); } } return super.visit(n, ctx); }
initCallSite.addArgument(new FieldAccessExpr(new NameExpr(className), "class")); initCallSite.addArgument(new StringLiteralExpr(featName)); VariableDeclarator vd_FC = new VariableDeclarator(callSiteType, "_FC_" + featName, initCallSite);
/** * Java Parser can't differentiate between packages, internal types, and fields. * All three are lumped together into FieldAccessExpr. We need to differentiate them. */ private ResolvedType solveDotExpressionType(ResolvedReferenceTypeDeclaration parentType, FieldAccessExpr node) { // Fields and internal type declarations cannot have the same name. // Thus, these checks will always be mutually exclusive. if (parentType.hasField(node.getName().getId())) { return parentType.getField(node.getName().getId()).getType(); } else if (parentType.hasInternalType(node.getName().getId())) { return new ReferenceTypeImpl(parentType.getInternalType(node.getName().getId()), typeSolver); } else { throw new UnsolvedSymbolException(node.getName().getId()); } }
private static final String getAnnotationParamValue(String packageName, Object expr, List<String> imports) { String str = expr.toString(); if (expr instanceof FieldAccessExpr) { FieldAccessExpr fae = (FieldAccessExpr) expr; String className = getClassName(packageName, fae.getScope().toString(), imports); return String.format("%s.%s", className, fae.getField()); } else if (expr instanceof IntegerLiteralExpr) { return str; } else if (expr instanceof LongLiteralExpr) { return str; } else if (expr instanceof DoubleLiteralExpr) { return str; } else if (expr instanceof StringLiteralExpr) { return str; } return null; } // =========================================================================