Datasets:

Mlxa

/

java_methods

like 0

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final ModuleUsage that = (ModuleUsage)o; return myModuleName == that.myModuleName; }

equals

int () { return myModuleName; }

hashCode

void (final DependencyContext context, final PrintStream stream) { stream.println("ModuleUsage: " + context.getValue(myModuleName)); }

toStream

int () { return myOwner; }

getOwner

void (final DataOutput out) { try { out.writeByte(IMPORT_STATIC_ON_DEMAND_USAGE); DataInputOutputUtil.writeINT(out, myOwner); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final ImportStaticOnDemandUsage that = (ImportStaticOnDemandUsage)o; return myOwner == that.myOwner; }

equals

int () { return myOwner; }

hashCode

void (final DependencyContext context, final PrintStream stream) { stream.println("ImportStaticOnDemandUsage: " + context.getValue(myOwner)); }

toStream

int () { return super.hashCode() + 3; }

hashCode

void (final DataOutput out) { try { out.writeByte(CLASS_AS_GENERIC_BOUND_USAGE); DataInputOutputUtil.writeINT(out, myClassName); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

void (final DependencyContext context, final PrintStream stream) { stream.println("ClassAsGenericBoundUsage: " + context.getValue(myClassName)); }

toStream

int () { return myClassName; }

getOwner

void (final DataOutput out) { try { out.writeByte(CLASS_EXTENDS_USAGE); DataInputOutputUtil.writeINT(out, myClassName); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

int () { return myClassName + 1; }

hashCode

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ClassExtendsUsage that = (ClassExtendsUsage)o; if (myClassName != that.myClassName) return false; return true; }

equals

void (final DependencyContext context, final PrintStream stream) { stream.println("ClassExtendsUsage: " + context.getValue(myClassName)); }

toStream

void (final DataOutput out) { try { out.writeByte(CLASS_NEW_USAGE); DataInputOutputUtil.writeINT(out, myClassName); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

int () { return myClassName + 2; }

hashCode

void (final DependencyContext context, final PrintStream stream) { stream.println("ClassNewUsage: " + context.getValue(myClassName)); }

toStream

boolean (final AnnotationUsage annotationUsage) { if (!myType.equals(annotationUsage.myType)) { return false; } boolean argumentsSatisfy = false; if (myUsedArguments != null) { IntSet arguments = new IntOpenHashSet(myUsedArguments); arguments.removeAll(annotationUsage.myUsedArguments); // need to find annotation usages that do not mention arguments this annotation uses argumentsSatisfy = !arguments.isEmpty(); } boolean targetsSatisfy = false; if (myUsedTargets != null) { final Collection<ElemType> targets = EnumSet.copyOf(myUsedTargets); targets.retainAll(annotationUsage.myUsedTargets); targetsSatisfy = !targets.isEmpty(); } return argumentsSatisfy || targetsSatisfy; }

satisfies

void (final DataOutput out) { try { out.writeByte(ANNOTATION_USAGE); myType.save(out); RW.save(myUsedArguments, out); RW.save(myUsedTargets, elementTypeExternalizer, out); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

int () { return myType.className; }

getOwner

boolean (final Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; AnnotationUsage that = (AnnotationUsage)o; if (myUsedArguments != null ? !myUsedArguments.equals(that.myUsedArguments) : that.myUsedArguments != null) return false; if (myUsedTargets != null ? !myUsedTargets.equals(that.myUsedTargets) : that.myUsedTargets != null) return false; if (myType != null ? !myType.equals(that.myType) : that.myType != null) return false; return true; }

equals

int () { int result = myType != null ? myType.hashCode() : 0; result = 31 * result + (myUsedArguments != null ? myUsedArguments.hashCode() : 0); result = 31 * result + (myUsedTargets != null ? myUsedTargets.hashCode() : 0); return result; }

hashCode

void (final DependencyContext context, final PrintStream stream) { stream.println(" AnnotationUsage:"); stream.println(" Type : " + myType.getDescr(context)); final List<String> arguments = new LinkedList<>(); if (myUsedArguments != null) { myUsedArguments.forEach(value -> { arguments.add(context.getValue(value)); }); } Collections.sort(arguments); final List<String> targets = new LinkedList<>(); if (myUsedTargets != null) { for (final ElemType e : myUsedTargets) { targets.add(e.toString()); } } Collections.sort(targets); stream.println(" Arguments:"); for (final String s : arguments) { stream.println(" " + s); } stream.println(" Targets :"); for (final String s : targets) { stream.println(" " + s); } }

toStream

Usage (final DependencyContext context, final int name, final int owner, final int descr) { return context.getUsage(new FieldUsage(context, name, owner, descr)); }

createFieldUsage

Usage (final DependencyContext context, final int name, final int owner, final int descr) { return context.getUsage(new FieldAssignUsage(context, name, owner, descr)); }

createFieldAssignUsage

Usage (final DependencyContext context, final int name, final int owner, final String descr) { return context.getUsage(new MethodUsage(context, name, owner, descr)); }

createMethodUsage

Usage (final DependencyContext context, final int name, final int owner) { return context.getUsage(new MetaMethodUsage(name, owner)); }

createMetaMethodUsage

Usage (final DependencyContext context, final int name, final int owner) { return context.getUsage(new ImportStaticMemberUsage(name, owner)); }

createImportStaticMemberUsage

Usage (final DependencyContext context, final int owner) { return context.getUsage(new ImportStaticOnDemandUsage(owner)); }

createImportStaticOnDemandUsage

Usage (final DependencyContext context, final int name) { return context.getUsage(new ClassUsage(name)); }

createClassUsage

Usage (final DependencyContext context, final int name) { return context.getUsage(new ClassAsGenericBoundUsage(name)); }

createClassAsGenericBoundUsage

Usage (final DependencyContext context, final int name) { return context.getUsage(new ClassNewUsage(name)); }

createClassNewUsage

Usage (DependencyContext context, TypeRepr.ClassType type, IntSet usedArguments, Set<ElemType> targets) { return context.getUsage(new AnnotationUsage(type, usedArguments, targets)); }

createAnnotationUsage

Usage (final DependencyContext context, final int name) { return context.getUsage(new ModuleUsage(name)); }

createModuleUsage

DataExternalizer<Usage> (final DependencyContext context) { return new DataExternalizer<Usage>() { @Override public void save(final @NotNull DataOutput out, final Usage value) { value.save(out); } @Override public Usage read(@NotNull DataInput in) throws IOException { final byte tag = in.readByte(); switch (tag) { case CLASS_USAGE: return context.getUsage(new ClassUsage(in)); case CLASS_AS_GENERIC_BOUND_USAGE: return context.getUsage(new ClassAsGenericBoundUsage(in)); case CLASS_EXTENDS_USAGE: return context.getUsage(new ClassExtendsUsage(in)); case CLASS_NEW_USAGE: return context.getUsage(new ClassNewUsage(in)); case FIELD_USAGE: return context.getUsage(new FieldUsage(context, in)); case FIELD_ASSIGN_USAGE: return context.getUsage(new FieldAssignUsage(context, in)); case METHOD_USAGE: return context.getUsage(new MethodUsage(context, in)); case ANNOTATION_USAGE: return context.getUsage(new AnnotationUsage(context, in)); case METAMETHOD_USAGE: return context.getUsage(new MetaMethodUsage(in)); case MODULE_USAGE: return context.getUsage(new ModuleUsage(in)); case IMPORT_STATIC_MEMBER_USAGE: return context.getUsage(new ImportStaticMemberUsage(in)); case IMPORT_STATIC_ON_DEMAND_USAGE: return context.getUsage(new ImportStaticOnDemandUsage(in)); default: throw new IOException("Unknown usage with tag " + tag); } } }; }

externalizer

void (final @NotNull DataOutput out, final Usage value) { value.save(out); }

save

String (final DependencyContext context) { return context.getValue(type); }

getDescr

void (final DependencyContext context, final int owner, final Set<? super UsageRepr.Usage> s) { }

updateClassUsages

void (final DataOutput out) { try { out.writeByte(PRIMITIVE_TYPE); DataInputOutputUtil.writeINT(out, type); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final PrimitiveType that = (PrimitiveType)o; return type == that.type; }

equals

int () { return type; }

hashCode

AbstractType () { AbstractType current = this; while (current instanceof ArrayType) { current = ((ArrayType)current).elementType; } return current; }

getDeepElementType

String (final DependencyContext context) { return "[" + elementType.getDescr(context); }

getDescr

void (final DependencyContext context, final int owner, final Set<? super UsageRepr.Usage> s) { elementType.updateClassUsages(context, owner, s); }

updateClassUsages

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final ArrayType arrayType = (ArrayType)o; return elementType.equals(arrayType.elementType); }

equals

int () { return elementType.hashCode(); }

hashCode

void (final DataOutput out) { try { out.writeByte(ARRAY_TYPE); elementType.save(out); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

String (final DependencyContext context) { return "L" + context.getValue(className) + ";"; }

getDescr

void (final DependencyContext context, final int owner, final Set<? super UsageRepr.Usage> s) { s.add(UsageRepr.createClassUsage(context, className)); }

updateClassUsages

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ClassType type = (ClassType)o; if (className != type.className) return false; return true; }

equals

int () { return className; }

hashCode

void (final DataOutput out) { try { out.writeByte(CLASS_TYPE); DataInputOutputUtil.writeINT(out, className); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

ClassType (final DependencyContext context, final int s) { return context.getType(new ClassType(s)); }

createClassType

AbstractType (final DependencyContext context, final int descr) { return getType(InternedString.create(context, descr)); }

getType

AbstractType (final DependencyContext context, final String descr) { return getType(InternedString.create(context, descr)); }

getType

AbstractType (InternedString descr) { final DependencyContext context = descr.getContext(); final Type t = Type.getType(descr.asString()); switch (t.getSort()) { case Type.OBJECT: return context.getType(new ClassType(context.get(t.getClassName().replace('.', '/')))); case Type.ARRAY: return context.getType(new ArrayType(getType(context, t.getElementType()))); default: return context.getType(new PrimitiveType(descr.asInt())); } }

getType

AbstractType (final DependencyContext context, final Type t) { return getType(context, t.getDescriptor()); }

getType

AbstractType[] (final DependencyContext context, final Type[] t) { if(t.length == 0) return AbstractType.EMPTY_TYPE_ARRAY; final AbstractType[] r = new AbstractType[t.length]; for (int i = 0; i < r.length; i++) { r[i] = getType(context, t[i]); } return r; }

getType

void (final @NotNull DataOutput out, final T value) { value.save(out); }

save

void (final DependencyContext context, final PrintStream stream) { final OrderProvider op = new OrderProvider(context); forEachEntry((vs, value) -> op.register(value)); final int[] keys = op.get(); for (final int a : keys) { final Collection<V> b = get(a); stream.print(" Key: "); stream.println(context.getValue(a)); stream.println(" Values:"); final List<String> list = new LinkedList<>(); for (final V value : b) { if (value instanceof Streamable) { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); final PrintStream s = new PrintStream(baos); ((Streamable)value).toStream(context, s); list.add(baos.toString()); } else { list.add(value.toString()); } } Collections.sort(list); for (final String l : list) { stream.print(l); } stream.println(" End Of Values"); } }

toStream

void (DataOutput out) { try { DataInputOutputUtil.writeINT(out, paramIndex); type.save(out); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ParamAnnotation that = (ParamAnnotation)o; if (paramIndex != that.paramIndex) return false; if (!type.equals(that.type)) return false; return true; }

equals

int () { int result = paramIndex; result = 31 * result + type.hashCode(); return result; }

hashCode

void (String name, Object value) { }

visit

void (String name, String desc, String value) { myRetentionPolicy = RetentionPolicy.valueOf(value); }

visitEnum

AnnotationVisitor (String name, String desc) { return null; }

visitAnnotation

AnnotationVisitor (String name) { return null; }

visitArray

void () { }

visitEnd

void (String name, Object value) { }

visit

void (final String name, String desc, final String value) { myTargets.add(ElemType.valueOf(value)); }

visitEnum

AnnotationVisitor (String name, String desc) { return this; }

visitAnnotation

AnnotationVisitor (String name) { return this; }

visitArray

void () { }

visitEnd

String (final Object value, boolean isArray) { final StringBuilder descriptor = new StringBuilder(); descriptor.append("()"); if (isArray) { descriptor.append("["); } if (value instanceof Type) { descriptor.append("Ljava/lang/Class;"); } else { final String name = Type.getType(value.getClass()).getInternalName(); // only primitive, String, Class, Enum, another Annotation or array of any of these are allowed switch (name) { case "java/lang/Integer": descriptor.append("I;"); break; case "java/lang/Short": descriptor.append("S;"); break; case "java/lang/Long": descriptor.append("J;"); break; case "java/lang/Byte": descriptor.append("B;"); break; case "java/lang/Char": descriptor.append("C;"); break; case "java/lang/Boolean": descriptor.append("Z;"); break; case "java/lang/Float": descriptor.append("F;"); break; case "java/lang/Double": descriptor.append("D;"); break; default: descriptor.append("L").append(name).append(";"); break; } } return descriptor.toString(); }

getMethodDescr

void (String name, Object value) { final boolean isArray = name == null && myArrayName != null; final String argName; if (name != null) { argName = name; } else { argName = myArrayName; // not interested in collecting complete array value; need to know just array type myArrayName = null; } if (argName != null) { registerUsages(argName, getMethodDescr(value, isArray), value); } }

visit

void (String name, String desc, String value) { final boolean isArray = name == null && myArrayName != null; final String argName; if (name != null) { argName = name; } else { argName = myArrayName; // not interested in collecting complete array value; need to know just array type myArrayName = null; } if (argName != null) { registerUsages(argName, (isArray? "()[" : "()") + desc, value); } }

visitEnum

AnnotationVisitor (String name, String desc) { return new AnnotationCrawler((TypeRepr.ClassType)TypeRepr.getType(myContext, desc), myTarget); }

visitAnnotation

AnnotationVisitor (String name) { myArrayName = name; return this; }

visitArray

void (String argName, String methodDescr, Object value) { final int methodName = myContext.get(argName); if (value instanceof Type) { final String className = ((Type)value).getClassName().replace('.', '/'); myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(className))); } myUsages.add(UsageRepr.createMethodUsage(myContext, methodName, myType.className, methodDescr)); myUsages.add(UsageRepr.createMetaMethodUsage(myContext, methodName, myType.className)); myUsedArguments.add(methodName); }

registerUsages

void () { IntSet s = myAnnotationArguments.get(myType); if (s == null) { myAnnotationArguments.put(myType, myUsedArguments); } else { s.retainAll(myUsedArguments); } }

visitEnd

void (String mainClass) { myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(mainClass))); }

visitMainClass

void (String module, int access, String version) { if (isExplicit(access)) { // collect non-synthetic dependencies only myModuleRequires.add(new ModuleRequiresRepr(myContext, access, myContext.get(module), version)); } }

visitRequire

void (String packaze, int access, String... modules) { if (isExplicit(access)) { // collect non-synthetic dependencies only myModuleExports.add(new ModulePackageRepr(myContext, myContext.get(packaze), modules != null? Arrays.asList(modules) : Collections.emptyList())); } }

visitExport

void (String service) { myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(service))); }

visitUse

void (String service, String... providers) { myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(service))); if (providers != null) { for (String provider : providers) { myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(provider))); } } }

visitProvide

boolean (int access) { return (access & (Opcodes.ACC_SYNTHETIC | Opcodes.ACC_MANDATED)) == 0; }

isExplicit

void (final String sig) { if (sig != null) { try { new SignatureReader(sig).accept(mySignatureCrawler); } catch (Exception e) { LOG.info("Problems parsing signature \"" + sig + "\" in " + myContext.getValue(myFileName), e); } } }

processSignature

SignatureVisitor () { return mySignatureWithGenericBoundUsageCrawler; }

visitClassBound

SignatureVisitor () { return mySignatureWithGenericBoundUsageCrawler; }

visitInterfaceBound

SignatureVisitor (char wildcard) { return wildcard == '+' || wildcard == '-' ? mySignatureWithGenericBoundUsageCrawler : super.visitTypeArgument(wildcard); }

visitTypeArgument

void (String name) { final int className = myContext.get(name); myUsages.add(UsageRepr.createClassUsage(myContext, className)); myUsages.add(UsageRepr.createClassAsGenericBoundUsage(myContext, className)); }

visitClassType

boolean (final int access) { return (access & Opcodes.ACC_PRIVATE) == 0; }

notPrivate

ClassFileRepr () { if (!myTakeIntoAccount) { return null; } if (myIsModule) { return new ModuleRepr(myContext, myAccess, myVersion, myFileName, myName, myModuleRequires, myModuleExports, myUsages); } return new ClassRepr( myContext, myAccess, myFileName, myName, myContext.get(mySignature), myContext.get(mySuperClass), myInterfaces, myFields, myMethods, myAnnotations, myTargets, myRetentionPolicy, myContext.get(myOuterClassName.get()), myLocalClassFlag.get(), myAnonymousClassFlag.get(), myUsages, myIsGenerated ); }

getResult

void (int version, int access, String name, String sig, String superName, String[] interfaces) { myTakeIntoAccount = notPrivate(access); myAccess = access; myName = myContext.get(name); myVersion = version; mySignature = sig; mySuperClass = superName; myInterfaces = interfaces; myClassNameHolder.set(name); if (mySuperClass != null) { final int superclassName = myContext.get(mySuperClass); myUsages.add(UsageRepr.createClassUsage(myContext, superclassName)); //myUsages.add(UsageRepr.createClassExtendsUsage(myContext, superclassName)); } if (myInterfaces != null) { for (String it : myInterfaces) { final int interfaceName = myContext.get(it); myUsages.add(UsageRepr.createClassUsage(myContext, interfaceName)); //myUsages.add(UsageRepr.createClassExtendsUsage(myContext, interfaceName)); } } processSignature(sig); }

visit

void () { for (Map.Entry<TypeRepr.ClassType, Set<ElemType>> entry : myAnnotationTargets.entrySet()) { TypeRepr.ClassType type = entry.getKey(); Set<ElemType> targets = entry.getValue(); IntSet usedArguments = myAnnotationArguments.get(type); myUsages.add(UsageRepr.createAnnotationUsage(myContext, type, usedArguments, targets)); } }

visitEnd

ModuleVisitor (String name, int access, String version) { myIsModule = true; myAccess = access; myName = myContext.get(name); myVersion = myContext.get(version); return new ModuleCrawler(); }

visitModule

AnnotationVisitor (final String desc, final boolean visible) { if (desc.equals("Ljava/lang/annotation/Target;")) { return new AnnotationTargetCrawler(); } if (desc.equals("Ljava/lang/annotation/Retention;")) { return new AnnotationRetentionPolicyCrawler(); } final TypeRepr.ClassType annotationType = (TypeRepr.ClassType)TypeRepr.getType(myContext, desc); myAnnotations.add(annotationType); return new AnnotationCrawler(annotationType, (myAccess & Opcodes.ACC_ANNOTATION) > 0 ? ElemType.ANNOTATION_TYPE : ElemType.TYPE); }

visitAnnotation

void (String source, String debug) { }

visitSource