private <T> void printCtFieldAccess(CtFieldAccess<T> f) { enterCtExpression(f); try (Writable _context = context.modify()) { if ((f.getVariable().isStatic() || "class".equals(f.getVariable().getSimpleName())) && f.getTarget() instanceof CtTypeAccess) { _context.ignoreGenerics(true); if (target != null) { boolean isInitializeStaticFinalField = isInitializeStaticFinalField(f.getTarget()); boolean isStaticField = f.getVariable().isStatic(); boolean isImportedField = this.isImported(f.getVariable()); if (target.isImplicit() && !(f.getVariable().getFieldDeclaration() == null && this.env.getNoClasspath())) { final CtField<?> field = f.getVariable().getFieldDeclaration(); if (field != null) { final String fieldName = field.getSimpleName(); CtVariable<?> var = f.getVariable().map(new PotentialVariableDeclarationFunction(fieldName)).first(); if (var != field) { printer.writeComment(f.getFactory().createComment("ERROR: Missing field \"" + f.getVariable().getSimpleName() + "\", please check your model. The code may not compile.", CommentType.BLOCK)).writeSpace(); scan(f.getVariable());
private <T> void visitFieldAccess(CtFieldAccess<T> fieldAccess) { if ("class".equals(fieldAccess.getVariable().getSimpleName())) { Class<?> actualClass = fieldAccess.getVariable().getDeclaringType().getActualClass(); if (actualClass != null) { CtLiteral<Class<?>> literal = fieldAccess.getFactory().Core().createLiteral(); if ("length".equals(fieldAccess.getVariable().getSimpleName())) { CtExpression<?> target = fieldAccess.getTarget(); if (target instanceof CtNewArray<?>) { .isSubtypeOf(fieldAccess.getVariable().getDeclaringType())) { CtLiteral<CtFieldReference<?>> l = fieldAccess.getFactory().Core().createLiteral(); l.setValue(fieldAccess.getVariable()); setResult(l); return; CtField<?> f = fieldAccess.getVariable().getDeclaration(); if ((f != null) && f.getModifiers().contains(ModifierKind.FINAL)) { setResult(evaluate(f.getDefaultExpression()));
/** * In no classpath mode, when we build a field access, we have a binding typed by ProblemBinding. * This binding doesn't contain all information but we can get some of them. * * @param singleNameReference * Used to get the problem binding of the field access and the name of the declaring type. * @return a field access. */ <T> CtFieldAccess<T> createFieldAccessNoClasspath(SingleNameReference singleNameReference) { CtFieldAccess<T> va; if (isLhsAssignment(jdtTreeBuilder.getContextBuilder(), singleNameReference)) { va = jdtTreeBuilder.getFactory().Core().createFieldWrite(); } else { va = jdtTreeBuilder.getFactory().Core().createFieldRead(); } va.setVariable(jdtTreeBuilder.getReferencesBuilder().<T>getVariableReference((ProblemBinding) singleNameReference.binding)); final CtReference declaring = jdtTreeBuilder.getReferencesBuilder().getDeclaringReferenceFromImports(singleNameReference.token); if (declaring instanceof CtTypeReference && va.getVariable() != null) { final CtTypeReference<Object> declaringRef = (CtTypeReference<Object>) declaring; va.setTarget(jdtTreeBuilder.getFactory().Code().createTypeAccess(declaringRef)); va.getVariable().setDeclaringType(declaringRef); va.getVariable().setStatic(true); } return va; }
/** * In no classpath mode, when we build a field access, we have a binding typed by ProblemBinding. * We try to get all information we can get from this binding. * * @param qualifiedNameReference * Used to get the problem binding of the field access and the name of the declaring type. * @return a field access. */ <T> CtFieldAccess<T> createFieldAccessNoClasspath(QualifiedNameReference qualifiedNameReference) { boolean fromAssignment = isLhsAssignment(jdtTreeBuilder.getContextBuilder(), qualifiedNameReference); CtFieldAccess<T> fieldAccess = createFieldAccess(jdtTreeBuilder.getReferencesBuilder().<T>getVariableReference((ProblemBinding) qualifiedNameReference.binding), null, fromAssignment); // In no classpath mode and with qualified name, the type given by JDT is wrong... final char[][] declaringClass = CharOperation.subarray(qualifiedNameReference.tokens, 0, qualifiedNameReference.tokens.length - 1); final MissingTypeBinding declaringType = jdtTreeBuilder.getContextBuilder().compilationunitdeclaration.scope.environment.createMissingType(null, declaringClass); final CtTypeReference<T> declaringRef = jdtTreeBuilder.getReferencesBuilder().getTypeReference(declaringType); fieldAccess.getVariable().setDeclaringType(declaringRef); fieldAccess.getVariable().setStatic(true); fieldAccess.setTarget(jdtTreeBuilder.getFactory().Code().createTypeAccess(declaringRef)); // In no classpath mode and with qualified name, the binding doesn't have a good name. fieldAccess.getVariable() .setSimpleName(createQualifiedTypeName(CharOperation.subarray(qualifiedNameReference.tokens, qualifiedNameReference.tokens.length - 1, qualifiedNameReference.tokens.length))); return fieldAccess; }
return convertElementToRuntimeObject(((CtFieldAccess<?>) value).getVariable()); } else if (value instanceof CtNewArray) { return toArray((CtNewArray) value);
if (parent instanceof CtFieldAccess) { CtFieldAccess field = (CtFieldAccess) parent; CtFieldReference localReference = field.getVariable(); declaringType = localReference.getDeclaringType(); reference = localReference;
/** * Creates a field access from its single name. * * @param singleNameReference * Used to build a variable reference and a target which will be contained in the field access. * @return a field access. */ <T> CtFieldAccess<T> createFieldAccess(SingleNameReference singleNameReference) { CtFieldAccess<T> va; if (isLhsAssignment(jdtTreeBuilder.getContextBuilder(), singleNameReference)) { va = jdtTreeBuilder.getFactory().Core().createFieldWrite(); } else { va = jdtTreeBuilder.getFactory().Core().createFieldRead(); } va.setVariable(jdtTreeBuilder.getReferencesBuilder().<T>getVariableReference(singleNameReference.fieldBinding().original())); if (va.getVariable() != null) { final CtFieldReference<T> ref = va.getVariable(); if (ref.isStatic() && !ref.getDeclaringType().isAnonymous()) { va.setTarget(jdtTreeBuilder.getFactory().Code().createTypeAccess(ref.getDeclaringType())); } else if (!ref.isStatic()) { va.setTarget(jdtTreeBuilder.getFactory().Code().createThisAccess(jdtTreeBuilder.getReferencesBuilder().getTypeReference(singleNameReference.actualReceiverType), true)); } } return va; }
@Override public <T> void visitCtFieldAccess(CtFieldAccess<T> f) { scan(f.getVariable()); }
final CtFieldReference variable = ((CtFieldAccess) caseStatement.getCaseExpression()).getVariable();
private static List<CtFieldReference<?>> getVarargs(CtClass<? extends Template<?>> root, List<CtInvocation<?>> variables) { List<CtFieldReference<?>> fields = new ArrayList<CtFieldReference<?>>(); for (CtFieldReference<?> field : root.getReference().getAllFields()) { if (field.getType().getActualClass() == CtStatementList.class) { boolean alreadyAdded = false; for (CtInvocation<?> invocation : variables) { alreadyAdded |= ((CtFieldAccess<?>) invocation.getTarget()).getVariable().getDeclaration().equals(field); } if (!alreadyAdded) { fields.add(field); } } } return fields; }
private boolean checkAccessedViaStageRefs(CtExpression<?> target) { if (target == null || target instanceof CtThisAccess) return true; if (target instanceof CtFieldAccess) { CtFieldAccess fieldAccess = (CtFieldAccess) target; CtField field = fieldAccess.getVariable().getDeclaration(); if (field != null && field.getAnnotation(StageRef.class) != null) { return checkAccessedViaStageRefs(fieldAccess.getTarget()); } } return false; }
@Override public <T> void visitCtFieldAccess(CtFieldAccess<T> f) { enter(f); scan(f.getVariable()); // scan(fieldAccess.getType()); scan(f.getAnnotations()); scanReferences(f.getTypeCasts()); scan(f.getVariable()); scan(f.getTarget()); exit(f); }
@Override public <T> void visitCtFieldAccess(CtFieldAccess<T> f) { enter(f); scan(f.getVariable()); // scan(fieldAccess.getType()); scan(f.getAnnotations()); scanReferences(f.getTypeCasts()); scan(f.getVariable()); scan(f.getTarget()); exit(f); }
private CompilationNode referencedCompilationNode( DependencyNode node, CtExpression<?> invocationTarget) { CompilationNode referencedNode; if (invocationTarget == null || invocationTarget instanceof CtThisAccess) { CtClass<?> ctClass = cxt.getAnyStagedClassByDependencyNode(node); referencedNode = cxt.getCompilationNode(ctClass); } else { CtField field = ((CtFieldAccess) invocationTarget) .getVariable().getDeclaration(); referencedNode = cxt.getCompilationNode(cxt.getReferencedClass(field)); } return referencedNode; }
private void guardFieldsAccess() { cxt.allNodes().forEach(node -> { List<CtFieldAccess<?>> fieldAccesses = node.filterBlocksForBuildingDeps((CtFieldAccess<?> fa) -> true); fieldAccesses.forEach((CtFieldAccess fa) -> { CtField<?> field = fa.getVariable().getDeclaration(); if (field != null) { StageModel stage = cxt.getStageModel(field); if (stage != null && stage != node) { CtExpression<?> target = fa.getTarget(); CtTargetedExpression<?, CtExpression<?>> access = stage.fieldAccess(target, field); if (target != null) target.setParent(access); fa.replace(access); } } }); }); }
@SuppressWarnings("unchecked") @Override public void apply() { olderNameOfVariable.clear(); for (String placeholder : palceholdersToVariables.keySet()) { List<CtVariableAccess> variables = palceholdersToVariables.get(placeholder); for (CtVariableAccess variableUnderAnalysis : variables) { this.olderNameOfVariable.put(variableUnderAnalysis, variableUnderAnalysis.getVariable().getSimpleName()); variableUnderAnalysis.getVariable().setSimpleName(placeholder); // workaround: Problems with var Shadowing variableUnderAnalysis.getFactory().getEnvironment().setNoClasspath(true); if (variableUnderAnalysis instanceof CtFieldAccess) { CtFieldAccess fieldAccess = (CtFieldAccess) variableUnderAnalysis; fieldAccess.getVariable().setDeclaringType(null); } } } }
@Override public <T> void visitCtFieldAccess(CtFieldAccess<T> f) { enterCtExpression(f); if (f.getTarget() != null) { scan(f.getTarget()); write("."); context.ignoreStaticAccess = true; } context.ignoreGenerics = true; scan(f.getVariable()); context.ignoreGenerics = false; context.ignoreStaticAccess = false; exitCtExpression(f); }
@Override public void apply() { // previousVariable.replace(newLiteral); previousname = affectedVariable.getVariable().getSimpleName(); affectedVariable.getVariable().setSimpleName(placeholder_name); //Workarround affectedVariable.getFactory().getEnvironment().setNoClasspath(true); if (affectedVariable instanceof CtFieldAccess) { CtFieldAccess fieldAccess = (CtFieldAccess) affectedVariable; fieldAccess.getVariable().setDeclaringType(null); } }
@Override public <T> void visitCtFieldAccess(CtFieldAccess<T> f) { enter(f); scan(f.getAnnotations()); scan(f.getType()); scanReferences(f.getTypeCasts()); scan(f.getTarget()); scan(f.getVariable()); exit(f); }
@Override public void visitCtForEach(CtForEach foreach) { if (foreach.getExpression() instanceof CtFieldAccess) { CtFieldAccess<?> fa = (CtFieldAccess<?>) foreach.getExpression(); if (Parameters.isParameterSource(fa.getVariable())) { Object[] value = (Object[]) Parameters.getValue(template, fa.getVariable().getSimpleName(), null); CtBlock<?> l = foreach.getFactory().Core().createBlock(); CtStatement body = foreach.getBody(); for (Object element : value) { CtStatement b = foreach.getFactory().Core().clone(body); for (CtVariableAccess<?> va : Query.getElements(b, new VariableAccessFilter<CtVariableAccess<?>>(foreach.getVariable().getReference()))) { va.replace((CtExpression) element); } l.addStatement(b); } foreach.replace(l); throw new SkipException(foreach); } } super.visitCtForEach(foreach); }