/** * Determine if the given ClassNode values have the same package name. * * @param first a ClassNode * @param second a ClassNode * @return true if both given nodes have the same package name * @throws NullPointerException if either of the given nodes are null */ public static boolean samePackageName(ClassNode first, ClassNode second) { return Objects.equals(first.getPackageName(), second.getPackageName()); }
private void assertImportIsAllowed(final String className) { if (importsWhitelist != null && !importsWhitelist.contains(className)) { if (starImportsWhitelist != null) { // we should now check if the import is in the star imports ClassNode node = ClassHelper.make(className); final String packageName = node.getPackageName(); if (!starImportsWhitelist.contains(packageName + ".*")) { throw new SecurityException("Importing [" + className + "] is not allowed"); } } else { throw new SecurityException("Importing [" + className + "] is not allowed"); } } if (importsBlacklist != null && importsBlacklist.contains(className)) { throw new SecurityException("Importing [" + className + "] is not allowed"); } // check that there's no star import blacklist if (starImportsBlacklist != null) { ClassNode node = ClassHelper.make(className); final String packageName = node.getPackageName(); if (starImportsBlacklist.contains(packageName + ".*")) { throw new SecurityException("Importing [" + className + "] is not allowed"); } } }
private static List<AnnotationNode> getTargetListFromAnnotations(ClassNode alias) { List<AnnotationNode> annotations = alias.getAnnotations(); if (annotations.size() < 2) { return Collections.emptyList(); } List<AnnotationNode> ret = new ArrayList<AnnotationNode>(annotations.size()); for (AnnotationNode an : annotations) { ClassNode type = an.getClassNode(); if (type.getName().equals(AnnotationCollector.class.getName()) || "java.lang.annotation".equals(type.getPackageName())) continue; AnnotationNode toAdd = new AnnotationNode(type); copyMembers(an, toAdd); ret.add(toAdd); } return ret; }
String packageName = classNode.getPackageName(); if (packageName != null) { out.println("package " + packageName + ";\n");
private static boolean isValidFieldNodeForByteCodeAccess(FieldNode fn, ClassNode accessingNode) { if (fn == null) return false; ClassNode declaringClass = fn.getDeclaringClass(); // same class is always allowed access if (Modifier.isPublic(fn.getModifiers()) || declaringClass.equals(accessingNode)) return true; boolean samePackages = samePackages(declaringClass.getPackageName(), accessingNode.getPackageName()); // protected means same class or same package, or subclass if (Modifier.isProtected(fn.getModifiers()) && (samePackages || accessingNode.isDerivedFrom(declaringClass))) { return true; } if (!fn.isPrivate()) { // package private is the only modifier left. It means same package is allowed, subclass not, same class is return samePackages; } return false; }
public void testPackageName() { assertEquals("Package", null, classNode.getPackageName()); ClassNode packageNode = new ClassNode("com.acme.Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); assertEquals("Package", "com.acme", packageNode.getPackageName()); } }
/** * Given a method node, checks if we are calling a private method from an inner class. */ private void checkOrMarkPrivateAccess(Expression source, MethodNode mn) { if (mn == null) { return; } ClassNode declaringClass = mn.getDeclaringClass(); ClassNode enclosingClassNode = typeCheckingContext.getEnclosingClassNode(); if (declaringClass != enclosingClassNode || typeCheckingContext.getEnclosingClosure() != null) { int mods = mn.getModifiers(); boolean sameModule = declaringClass.getModule() == enclosingClassNode.getModule(); String packageName = declaringClass.getPackageName(); if (packageName == null) { packageName = ""; } if ((Modifier.isPrivate(mods) && sameModule)) { addPrivateFieldOrMethodAccess(source, declaringClass, StaticTypesMarker.PV_METHODS_ACCESS, mn); } else if (Modifier.isProtected(mods) && !packageName.equals(enclosingClassNode.getPackageName()) && !implementsInterfaceOrIsSubclassOf(enclosingClassNode, declaringClass)) { ClassNode cn = enclosingClassNode; while ((cn = cn.getOuterClass()) != null) { if (implementsInterfaceOrIsSubclassOf(cn, declaringClass)) { addPrivateFieldOrMethodAccess(source, cn, StaticTypesMarker.PV_METHODS_ACCESS, mn); break; } } } } }
ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(aliasedNode.getPackageName() + ".", className); if (resolve(tmp, true, true, false)) { type.setRedirect(tmp.redirect());
private boolean getField(PropertyExpression expression, Expression receiver, ClassNode receiverType, String name) { ClassNode classNode = controller.getClassNode(); boolean safe = expression.isSafe(); boolean implicitThis = expression.isImplicitThis(); if (makeGetField(receiver, receiverType, name, safe, implicitThis, samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return true; if (receiver instanceof ClassExpression) { if (makeGetField(receiver, receiver.getType(), name, safe, implicitThis, samePackages(receiver.getType().getPackageName(), classNode.getPackageName()))) return true; if (makeGetPrivateFieldWithBridgeMethod(receiver, receiver.getType(), name, safe, implicitThis)) return true; } if (makeGetPrivateFieldWithBridgeMethod(receiver, receiverType, name, safe, implicitThis)) return true; boolean isClassReceiver = false; if (isClassClassNodeWrappingConcreteType(receiverType)) { isClassReceiver = true; receiverType = receiverType.getGenericsTypes()[0].getType(); } if (isClassReceiver && makeGetField(receiver, CLASS_Type, name, safe, false, true)) return true; if (receiverType.isEnum()) { controller.getMethodVisitor().visitFieldInsn(GETSTATIC, BytecodeHelper.getClassInternalName(receiverType), name, BytecodeHelper.getTypeDescription(receiverType)); controller.getOperandStack().push(receiverType); return true; } return false; } }
if (an == collector || "java.lang.annotation".equals(an.getClassNode().getPackageName())) { continue;
if (type.getPackageName() == null && node.getPackageName() != null) { String oldTypeName = type.getName(); type.setName(node.getPackageName() + "." + oldTypeName); if (resolve(type, false, false, true)) continue; type.setName(oldTypeName);
if (makeGetField(receiver, receiverType, property, safe, implicitThis, samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return;
if (classNode != null) { name = classNode.getNameWithoutPackage() + "$" + name; String fullName = dot(classNode.getPackageName(), name); classNode = new InnerClassNode(classNode, fullName, modifiers, superClass, interfaces, null); } else {
if (classNode != null) { name = classNode.getNameWithoutPackage() + "$" + name; String fullName = dot(classNode.getPackageName(), name); if (classNode.isInterface()) { modifiers |= Opcodes.ACC_STATIC;
return false; if (!Objects.equals(receiverType.getPackageName(), current.getPackageName())) { return false;
if (makeGetField(receiver, receiverType, methodName, safe, implicitThis, samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return; if (receiver instanceof ClassExpression) { if (makeGetField(receiver, receiver.getType(), methodName, safe, implicitThis, samePackages(receiver.getType().getPackageName(), classNode.getPackageName()))) return; if (makeGetPropertyWithGetter(receiver, receiver.getType(), methodName, safe, implicitThis)) return; if (makeGetPrivateFieldWithBridgeMethod(receiver, receiver.getType(), methodName, safe, implicitThis)) return;
&& !receiverType.equals(declaringClass)) && receiverType.isDerivedFrom(declaringClass) && !receiverType.getPackageName().equals(classNode.getPackageName())) {
private static String getPackageName(ClassNode node) { if (node.getPackageName() != null) { return node.getPackageName(); } return ""; // NOI18N } }
public ASTClass(ClassNode node, String fqn) { super(node, node.getPackageName(), node.getNameWithoutPackage()); if (fqn != null) { this.fqn = fqn; } else { this.fqn = getName(); } }
private String getCurrentPackageName(ModuleNode moduleNode) { if (moduleNode != null) { return moduleNode.getPackageName(); } else { ClassNode node = ContextHelper.getSurroundingClassNode(request); if (node != null) { return node.getPackageName(); } } return ""; }