Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
2,000 |
void () { }
|
visitEnd
|
2,001 |
void (String name, Object value) { }
|
visit
|
2,002 |
void (final String name, String desc, final String value) { myTargets.add(ElemType.valueOf(value)); }
|
visitEnum
|
2,003 |
AnnotationVisitor (String name, String desc) { return this; }
|
visitAnnotation
|
2,004 |
AnnotationVisitor (String name) { return this; }
|
visitArray
|
2,005 |
void () { }
|
visitEnd
|
2,006 |
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
|
2,007 |
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
|
2,008 |
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
|
2,009 |
AnnotationVisitor (String name, String desc) { return new AnnotationCrawler((TypeRepr.ClassType)TypeRepr.getType(desc), myTarget); }
|
visitAnnotation
|
2,010 |
AnnotationVisitor (String name) { myArrayName = name; return this; }
|
visitArray
|
2,011 |
void (String methodName, String methodDescr, Object value) { if (value instanceof Type) { final String className = ((Type)value).getClassName().replace('.', '/'); addUsage(new ClassUsage(className)); } addUsage(new MethodUsage(myType.getJvmName(), methodName, methodDescr)); //myUsages.add(UsageRepr.createMetaMethodUsage(myContext, methodName, myType.className)); myUsedArguments.add(methodName); }
|
registerUsages
|
2,012 |
void () { Set<String> s = myAnnotationArguments.get(myType); if (s == null) { myAnnotationArguments.put(myType, myUsedArguments); } else { s.retainAll(myUsedArguments); } }
|
visitEnd
|
2,013 |
void (String mainClass) { addUsage(new ClassUsage(mainClass)); }
|
visitMainClass
|
2,014 |
void (String module, int access, String version) { if (isExplicit(access)) { // collect non-synthetic dependencies only myModuleRequires.add(new ModuleRequires(new JVMFlags(access), module, version)); } }
|
visitRequire
|
2,015 |
void (String packaze, int access, String... modules) { if (isExplicit(access)) { // collect non-synthetic dependencies only myModuleExports.add(new ModulePackage(packaze, modules != null? Arrays.asList(modules) : Collections.emptyList())); } }
|
visitExport
|
2,016 |
void (String service) { addUsage(new ClassUsage(service)); }
|
visitUse
|
2,017 |
void (String service, String... providers) { addUsage(new ClassUsage(service)); if (providers != null) { for (String provider : providers) { addUsage(new ClassUsage(provider)); } } }
|
visitProvide
|
2,018 |
boolean (int access) { return (access & (Opcodes.ACC_SYNTHETIC | Opcodes.ACC_MANDATED)) == 0; }
|
isExplicit
|
2,019 |
void (final String sig) { if (sig != null) { try { new SignatureReader(sig).accept(mySignatureCrawler); } catch (Exception e) { LOG.info("Problems parsing signature \"" + sig + "\" in " + myFileName, e); } } }
|
processSignature
|
2,020 |
SignatureVisitor () { return mySignatureWithGenericBoundUsageCrawler; }
|
visitClassBound
|
2,021 |
SignatureVisitor () { return mySignatureWithGenericBoundUsageCrawler; }
|
visitInterfaceBound
|
2,022 |
SignatureVisitor (char wildcard) { return wildcard == '+' || wildcard == '-'? mySignatureWithGenericBoundUsageCrawler : super.visitTypeArgument(wildcard); }
|
visitTypeArgument
|
2,023 |
void (String name) { super.visitClassType(name); addUsage(new ClassAsGenericBoundUsage(name)); }
|
visitClassType
|
2,024 |
JvmClassNodeBuilder (String filePath, ClassReader cr, boolean isGenerated) { JvmClassNodeBuilder builder = new JvmClassNodeBuilder(filePath, isGenerated); try { cr.accept(builder, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG); } catch (RuntimeException e) { throw new RuntimeException("Corrupted .class file: " + filePath, e); } return builder; }
|
create
|
2,025 |
JvmNodeReferenceID () { return new JvmNodeReferenceID(myName); }
|
getReferenceID
|
2,026 |
void (Usage usage) { ReferenceID owner = usage.getElementOwner(); if (!(owner instanceof JvmNodeReferenceID) || !JvmClass.OBJECT_CLASS_NAME.equals(((JvmNodeReferenceID)owner).getNodeName())) { myUsages.add(usage); } }
|
addUsage
|
2,027 |
void (int version, int access, String name, String sig, String superName, String[] interfaces) { myAccess = access; myName = name; myVersion = String.valueOf(version); mySignature = sig; mySuperClass = superName; myInterfaces = Iterators.asIterable(interfaces); myClassNameHolder.set(name); processSignature(sig); }
|
visit
|
2,028 |
void () { for (Map.Entry<TypeRepr.ClassType, Set<ElemType>> entry : myAnnotationTargets.entrySet()) { TypeRepr.ClassType type = entry.getKey(); Set<ElemType> targets = entry.getValue(); Set<String> usedArguments = myAnnotationArguments.get(type); addUsage(new AnnotationUsage(type, usedArguments != null? usedArguments : Collections.emptyList(), targets)); } }
|
visitEnd
|
2,029 |
ModuleVisitor (String name, int access, String version) { myIsModule = true; myAccess = access; myName = name; myVersion = version; return new ModuleCrawler(); }
|
visitModule
|
2,030 |
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(); } TypeRepr.ClassType annotationType = (TypeRepr.ClassType)TypeRepr.getType(desc); myAnnotations.add(annotationType); return new AnnotationCrawler(annotationType, (myAccess & Opcodes.ACC_ANNOTATION) > 0? ElemType.ANNOTATION_TYPE : ElemType.TYPE); }
|
visitAnnotation
|
2,031 |
void (String source, String debug) { }
|
visitSource
|
2,032 |
FieldVisitor (final int access, final String name, final String desc, final String signature, final Object value) { processSignature(signature); return new FieldVisitor(ASM_API_VERSION) { final Set<TypeRepr.ClassType> annotations = new HashSet<>(); @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { final TypeRepr.ClassType annotation = (TypeRepr.ClassType)TypeRepr.getType(desc); annotations.add(annotation); return new AnnotationCrawler(annotation, ElemType.FIELD); } @Override public void visitEnd() { try { super.visitEnd(); } finally { if ((access & Opcodes.ACC_SYNTHETIC) == 0) { myFields.add(new JvmField(new JVMFlags(access), signature, name, desc, annotations, value)); } } } }; }
|
visitField
|
2,033 |
AnnotationVisitor (String desc, boolean visible) { final TypeRepr.ClassType annotation = (TypeRepr.ClassType)TypeRepr.getType(desc); annotations.add(annotation); return new AnnotationCrawler(annotation, ElemType.FIELD); }
|
visitAnnotation
|
2,034 |
void () { try { super.visitEnd(); } finally { if ((access & Opcodes.ACC_SYNTHETIC) == 0) { myFields.add(new JvmField(new JVMFlags(access), signature, name, desc, annotations, value)); } } }
|
visitEnd
|
2,035 |
MethodVisitor (final int access, final String n, final String desc, final String signature, final String[] exceptions) { final Ref<Object> defaultValue = Ref.create(); final Set<TypeRepr.ClassType> annotations = new HashSet<>(); final Set<ParamAnnotation> paramAnnotations = new HashSet<>(); processSignature(signature); return new MethodVisitor(ASM_API_VERSION) { @Override public void visitEnd() { if ((access & Opcodes.ACC_SYNTHETIC) == 0 || (access & Opcodes.ACC_BRIDGE) > 0) { myMethods.add(new JvmMethod(new JVMFlags(access), signature, n, desc, annotations, paramAnnotations, Iterators.asIterable(exceptions), defaultValue.get())); } } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { final TypeRepr.ClassType annoType = (TypeRepr.ClassType)TypeRepr.getType(desc); annotations.add(annoType); return new AnnotationCrawler(annoType, "<init>".equals(n)? ElemType.CONSTRUCTOR : ElemType.METHOD); } @Override public AnnotationVisitor visitAnnotationDefault() { return new AnnotationVisitor(ASM_API_VERSION) { private @Nullable List<Object> myAcc; @Override public void visit(String name, Object value) { collectValue(value); } @Override public void visitEnum(String name, String desc, String value) { collectValue(value); } @Override public AnnotationVisitor visitArray(String name) { myAcc = new SmartList<>(); return this; } @Override public void visitEnd() { if (myAcc != null) { Object[] template = null; if (!myAcc.isEmpty()) { final Object elem = myAcc.get(0); if (elem != null) { template = ArrayUtil.newArray(elem.getClass(), 0); } } defaultValue.set(template != null? myAcc.toArray(template) : myAcc.toArray()); } } private void collectValue(Object value) { if (myAcc != null) { myAcc.add(value); } else { defaultValue.set(value); } } }; } @Override public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { final TypeRepr.ClassType annoType = (TypeRepr.ClassType)TypeRepr.getType(desc); paramAnnotations.add(new ParamAnnotation(parameter, annoType)); return new AnnotationCrawler(annoType, ElemType.PARAMETER); } @Override public void visitLdcInsn(Object cst) { if (cst instanceof Type) { addUsage(new ClassUsage(((Type)cst).getInternalName())); } super.visitLdcInsn(cst); } @Override public void visitMultiANewArrayInsn(String desc, int dims) { final TypeRepr.ArrayType typ = (TypeRepr.ArrayType)TypeRepr.getType(desc); Iterators.collect(typ.getUsages(), myUsages); final TypeRepr element = typ.getDeepElementType(); if (element instanceof TypeRepr.ClassType) { addUsage(new ClassNewUsage(((TypeRepr.ClassType)element).getJvmName())); } super.visitMultiANewArrayInsn(desc, dims); } @Override public void visitLocalVariable(String n, String desc, String signature, Label start, Label end, int index) { processSignature(signature); Iterators.collect(TypeRepr.getType(desc).getUsages(), myUsages); super.visitLocalVariable(n, desc, signature, start, end, index); } @Override public void visitTryCatchBlock(Label start, Label end, Label handler, String type) { if (type != null) { Iterators.collect(new TypeRepr.ClassType(type).getUsages(), myUsages); } super.visitTryCatchBlock(start, end, handler, type); } @Override public void visitTypeInsn(int opcode, String type) { final TypeRepr typ = type.startsWith("[")? TypeRepr.getType(type) : new TypeRepr.ClassType(type); if (opcode == Opcodes.NEW) { addUsage(new ClassUsage(((TypeRepr.ClassType)typ).getJvmName())); addUsage(new ClassNewUsage(((TypeRepr.ClassType)typ).getJvmName())); final int ktLambdaMarker = type.indexOf(KOTLIN_LAMBDA_USAGE_CLASS_MARKER); if (ktLambdaMarker > 0) { final int ifNameStart = ktLambdaMarker + KOTLIN_LAMBDA_USAGE_CLASS_MARKER.length(); final int ifNameEnd = type.indexOf("$", ifNameStart); if (ifNameEnd > ifNameStart) { addUsage(new ClassNewUsage(type.substring(ifNameStart, ifNameEnd).replace('_', '/'))); } } } else if (opcode == Opcodes.ANEWARRAY) { if (typ instanceof TypeRepr.ClassType) { addUsage(new ClassUsage(((TypeRepr.ClassType)typ).getJvmName())); addUsage(new ClassNewUsage(((TypeRepr.ClassType)typ).getJvmName())); } } Iterators.collect(typ.getUsages(), myUsages); super.visitTypeInsn(opcode, type); } @Override public void visitFieldInsn(int opcode, String owner, String name, String desc) { registerFieldUsage(opcode, owner, name, desc); super.visitFieldInsn(opcode, owner, name, desc); } @Override public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) { registerMethodUsage(owner, name, desc); super.visitMethodInsn(opcode, owner, name, desc, itf); } @Override public void visitInvokeDynamicInsn(String methodName, String desc, Handle bsm, Object... bsmArgs) { final Type returnType = Type.getReturnType(desc); Iterators.collect(TypeRepr.getType(returnType).getUsages(), myUsages); // common args processing for (Object arg : bsmArgs) { if (arg instanceof Type) { final Type type = (Type)arg; if (type.getSort() == Type.METHOD) { for (Type argType : type.getArgumentTypes()) { Iterators.collect(TypeRepr.getType(argType).getUsages(), myUsages); } Iterators.collect(TypeRepr.getType(type.getReturnType()).getUsages(), myUsages); } else { Iterators.collect(TypeRepr.getType(type).getUsages(), myUsages); } } else if (arg instanceof Handle) { processMethodHandle((Handle)arg); } } if (LAMBDA_FACTORY_CLASS.equals(bsm.getOwner())) { // This invokeDynamic implements a lambda or method reference usage. // Need to register method usage for the corresponding SAM-type. // First three arguments to the bootstrap methods are provided automatically by VM. // Arguments in args array are expected to be as following: // [0]: Type: Signature and return type of method to be implemented by the function object. // [1]: Handle: implementation method handle // [2]: Type: The signature and return type that should be enforced dynamically at invocation time. May be the same as samMethodType, or may be a specialization of it // [...]: optional additional arguments if (returnType.getSort() == Type.OBJECT && bsmArgs.length >= 3) { if (bsmArgs[0] instanceof Type) { final Type samMethodType = (Type)bsmArgs[0]; if (samMethodType.getSort() == Type.METHOD) { registerMethodUsage(returnType.getInternalName(), methodName, samMethodType.getDescriptor()); // reflect dynamic proxy instantiation with NewClassUsage addUsage(new ClassNewUsage(returnType.getInternalName())); } } } } super.visitInvokeDynamicInsn(methodName, desc, bsm, bsmArgs); } private void processMethodHandle(Handle handle) { final String memberOwner = handle.getOwner(); if (memberOwner != null && !memberOwner.equals(myClassNameHolder.get())) { // do not register access to own class members final String memberName = handle.getName(); final String memberDescriptor = handle.getDesc(); final int opCode = getFieldAccessOpcode(handle); if (opCode > 0) { registerFieldUsage(opCode, memberOwner, memberName, memberDescriptor); } else { registerMethodUsage(memberOwner, memberName, memberDescriptor); } } } private void registerFieldUsage(int opcode, String owner, String fName, String desc) { if (opcode == Opcodes.PUTFIELD || opcode == Opcodes.PUTSTATIC) { addUsage(new FieldAssignUsage(owner, fName, desc)); } if (opcode == Opcodes.GETFIELD || opcode == Opcodes.GETSTATIC) { Iterators.collect(TypeRepr.getType(desc).getUsages(), myUsages); } addUsage(new FieldUsage(owner, fName, desc)); } private void registerMethodUsage(String owner, String name, @Nullable String desc) { //myUsages.add(UsageRepr.createMetaMethodUsage(myContext, methodName, methodOwner)); if (desc != null) { addUsage(new MethodUsage(owner, name, desc)); Iterators.collect(TypeRepr.getType(Type.getReturnType(desc)).getUsages(), myUsages); } else { // todo: verify for which methods null descriptor is passed addUsage(new MethodUsage(owner, name, "")); } } }; }
|
visitMethod
|
2,036 |
void () { if ((access & Opcodes.ACC_SYNTHETIC) == 0 || (access & Opcodes.ACC_BRIDGE) > 0) { myMethods.add(new JvmMethod(new JVMFlags(access), signature, n, desc, annotations, paramAnnotations, Iterators.asIterable(exceptions), defaultValue.get())); } }
|
visitEnd
|
2,037 |
AnnotationVisitor (String desc, boolean visible) { final TypeRepr.ClassType annoType = (TypeRepr.ClassType)TypeRepr.getType(desc); annotations.add(annoType); return new AnnotationCrawler(annoType, "<init>".equals(n)? ElemType.CONSTRUCTOR : ElemType.METHOD); }
|
visitAnnotation
|
2,038 |
AnnotationVisitor () { return new AnnotationVisitor(ASM_API_VERSION) { private @Nullable List<Object> myAcc; @Override public void visit(String name, Object value) { collectValue(value); } @Override public void visitEnum(String name, String desc, String value) { collectValue(value); } @Override public AnnotationVisitor visitArray(String name) { myAcc = new SmartList<>(); return this; } @Override public void visitEnd() { if (myAcc != null) { Object[] template = null; if (!myAcc.isEmpty()) { final Object elem = myAcc.get(0); if (elem != null) { template = ArrayUtil.newArray(elem.getClass(), 0); } } defaultValue.set(template != null? myAcc.toArray(template) : myAcc.toArray()); } } private void collectValue(Object value) { if (myAcc != null) { myAcc.add(value); } else { defaultValue.set(value); } } }; }
|
visitAnnotationDefault
|
2,039 |
void (String name, Object value) { collectValue(value); }
|
visit
|
2,040 |
void (String name, String desc, String value) { collectValue(value); }
|
visitEnum
|
2,041 |
AnnotationVisitor (String name) { myAcc = new SmartList<>(); return this; }
|
visitArray
|
2,042 |
void () { if (myAcc != null) { Object[] template = null; if (!myAcc.isEmpty()) { final Object elem = myAcc.get(0); if (elem != null) { template = ArrayUtil.newArray(elem.getClass(), 0); } } defaultValue.set(template != null? myAcc.toArray(template) : myAcc.toArray()); } }
|
visitEnd
|
2,043 |
void (Object value) { if (myAcc != null) { myAcc.add(value); } else { defaultValue.set(value); } }
|
collectValue
|
2,044 |
AnnotationVisitor (int parameter, String desc, boolean visible) { final TypeRepr.ClassType annoType = (TypeRepr.ClassType)TypeRepr.getType(desc); paramAnnotations.add(new ParamAnnotation(parameter, annoType)); return new AnnotationCrawler(annoType, ElemType.PARAMETER); }
|
visitParameterAnnotation
|
2,045 |
void (Object cst) { if (cst instanceof Type) { addUsage(new ClassUsage(((Type)cst).getInternalName())); } super.visitLdcInsn(cst); }
|
visitLdcInsn
|
2,046 |
void (String desc, int dims) { final TypeRepr.ArrayType typ = (TypeRepr.ArrayType)TypeRepr.getType(desc); Iterators.collect(typ.getUsages(), myUsages); final TypeRepr element = typ.getDeepElementType(); if (element instanceof TypeRepr.ClassType) { addUsage(new ClassNewUsage(((TypeRepr.ClassType)element).getJvmName())); } super.visitMultiANewArrayInsn(desc, dims); }
|
visitMultiANewArrayInsn
|
2,047 |
void (String n, String desc, String signature, Label start, Label end, int index) { processSignature(signature); Iterators.collect(TypeRepr.getType(desc).getUsages(), myUsages); super.visitLocalVariable(n, desc, signature, start, end, index); }
|
visitLocalVariable
|
2,048 |
void (Label start, Label end, Label handler, String type) { if (type != null) { Iterators.collect(new TypeRepr.ClassType(type).getUsages(), myUsages); } super.visitTryCatchBlock(start, end, handler, type); }
|
visitTryCatchBlock
|
2,049 |
void (int opcode, String type) { final TypeRepr typ = type.startsWith("[")? TypeRepr.getType(type) : new TypeRepr.ClassType(type); if (opcode == Opcodes.NEW) { addUsage(new ClassUsage(((TypeRepr.ClassType)typ).getJvmName())); addUsage(new ClassNewUsage(((TypeRepr.ClassType)typ).getJvmName())); final int ktLambdaMarker = type.indexOf(KOTLIN_LAMBDA_USAGE_CLASS_MARKER); if (ktLambdaMarker > 0) { final int ifNameStart = ktLambdaMarker + KOTLIN_LAMBDA_USAGE_CLASS_MARKER.length(); final int ifNameEnd = type.indexOf("$", ifNameStart); if (ifNameEnd > ifNameStart) { addUsage(new ClassNewUsage(type.substring(ifNameStart, ifNameEnd).replace('_', '/'))); } } } else if (opcode == Opcodes.ANEWARRAY) { if (typ instanceof TypeRepr.ClassType) { addUsage(new ClassUsage(((TypeRepr.ClassType)typ).getJvmName())); addUsage(new ClassNewUsage(((TypeRepr.ClassType)typ).getJvmName())); } } Iterators.collect(typ.getUsages(), myUsages); super.visitTypeInsn(opcode, type); }
|
visitTypeInsn
|
2,050 |
void (int opcode, String owner, String name, String desc) { registerFieldUsage(opcode, owner, name, desc); super.visitFieldInsn(opcode, owner, name, desc); }
|
visitFieldInsn
|
2,051 |
void (int opcode, String owner, String name, String desc, boolean itf) { registerMethodUsage(owner, name, desc); super.visitMethodInsn(opcode, owner, name, desc, itf); }
|
visitMethodInsn
|
2,052 |
void (String methodName, String desc, Handle bsm, Object... bsmArgs) { final Type returnType = Type.getReturnType(desc); Iterators.collect(TypeRepr.getType(returnType).getUsages(), myUsages); // common args processing for (Object arg : bsmArgs) { if (arg instanceof Type) { final Type type = (Type)arg; if (type.getSort() == Type.METHOD) { for (Type argType : type.getArgumentTypes()) { Iterators.collect(TypeRepr.getType(argType).getUsages(), myUsages); } Iterators.collect(TypeRepr.getType(type.getReturnType()).getUsages(), myUsages); } else { Iterators.collect(TypeRepr.getType(type).getUsages(), myUsages); } } else if (arg instanceof Handle) { processMethodHandle((Handle)arg); } } if (LAMBDA_FACTORY_CLASS.equals(bsm.getOwner())) { // This invokeDynamic implements a lambda or method reference usage. // Need to register method usage for the corresponding SAM-type. // First three arguments to the bootstrap methods are provided automatically by VM. // Arguments in args array are expected to be as following: // [0]: Type: Signature and return type of method to be implemented by the function object. // [1]: Handle: implementation method handle // [2]: Type: The signature and return type that should be enforced dynamically at invocation time. May be the same as samMethodType, or may be a specialization of it // [...]: optional additional arguments if (returnType.getSort() == Type.OBJECT && bsmArgs.length >= 3) { if (bsmArgs[0] instanceof Type) { final Type samMethodType = (Type)bsmArgs[0]; if (samMethodType.getSort() == Type.METHOD) { registerMethodUsage(returnType.getInternalName(), methodName, samMethodType.getDescriptor()); // reflect dynamic proxy instantiation with NewClassUsage addUsage(new ClassNewUsage(returnType.getInternalName())); } } } } super.visitInvokeDynamicInsn(methodName, desc, bsm, bsmArgs); }
|
visitInvokeDynamicInsn
|
2,053 |
void (Handle handle) { final String memberOwner = handle.getOwner(); if (memberOwner != null && !memberOwner.equals(myClassNameHolder.get())) { // do not register access to own class members final String memberName = handle.getName(); final String memberDescriptor = handle.getDesc(); final int opCode = getFieldAccessOpcode(handle); if (opCode > 0) { registerFieldUsage(opCode, memberOwner, memberName, memberDescriptor); } else { registerMethodUsage(memberOwner, memberName, memberDescriptor); } } }
|
processMethodHandle
|
2,054 |
void (int opcode, String owner, String fName, String desc) { if (opcode == Opcodes.PUTFIELD || opcode == Opcodes.PUTSTATIC) { addUsage(new FieldAssignUsage(owner, fName, desc)); } if (opcode == Opcodes.GETFIELD || opcode == Opcodes.GETSTATIC) { Iterators.collect(TypeRepr.getType(desc).getUsages(), myUsages); } addUsage(new FieldUsage(owner, fName, desc)); }
|
registerFieldUsage
|
2,055 |
void (String owner, String name, @Nullable String desc) { //myUsages.add(UsageRepr.createMetaMethodUsage(myContext, methodName, methodOwner)); if (desc != null) { addUsage(new MethodUsage(owner, name, desc)); Iterators.collect(TypeRepr.getType(Type.getReturnType(desc)).getUsages(), myUsages); } else { // todo: verify for which methods null descriptor is passed addUsage(new MethodUsage(owner, name, "")); } }
|
registerMethodUsage
|
2,056 |
int (Handle handle) { switch (handle.getTag()) { case Opcodes.H_GETFIELD: return Opcodes.GETFIELD; case Opcodes.H_GETSTATIC: return Opcodes.GETSTATIC; case Opcodes.H_PUTFIELD: return Opcodes.PUTFIELD; case Opcodes.H_PUTSTATIC: return Opcodes.PUTSTATIC; default: return -1; } }
|
getFieldAccessOpcode
|
2,057 |
void (String name, String outerName, String innerName, int access) { if (name != null && name.equals(myClassNameHolder.get())) { // set outer class name only if we are parsing the real inner class and // not the reference to inner class inside some top-level class myAccess |= access; // information about some access flags for the inner class is missing from the mask passed to 'visit' method if (outerName != null) { myOuterClassName.set(outerName); } if (innerName == null) { myAnonymousClassFlag.set(true); } } }
|
visitInnerClass
|
2,058 |
void (final String owner, final String name, final String desc) { myOuterClassName.set(owner); if (name != null) { myLocalClassFlag.set(true); } }
|
visitOuterClass
|
2,059 |
void (String name) { }
|
visitFormalTypeParameter
|
2,060 |
SignatureVisitor () { return super.visitClassBound(); }
|
visitClassBound
|
2,061 |
SignatureVisitor () { return super.visitInterfaceBound(); }
|
visitInterfaceBound
|
2,062 |
SignatureVisitor () { return super.visitSuperclass(); }
|
visitSuperclass
|
2,063 |
SignatureVisitor () { return super.visitInterface(); }
|
visitInterface
|
2,064 |
SignatureVisitor () { return super.visitParameterType(); }
|
visitParameterType
|
2,065 |
SignatureVisitor () { return super.visitReturnType(); }
|
visitReturnType
|
2,066 |
SignatureVisitor () { return super.visitExceptionType(); }
|
visitExceptionType
|
2,067 |
void (char descriptor) { }
|
visitBaseType
|
2,068 |
void (String name) { }
|
visitTypeVariable
|
2,069 |
SignatureVisitor () { return super.visitArrayType(); }
|
visitArrayType
|
2,070 |
void (String name) { }
|
visitInnerClassType
|
2,071 |
void () { super.visitTypeArgument(); }
|
visitTypeArgument
|
2,072 |
SignatureVisitor (char wildcard) { return this; }
|
visitTypeArgument
|
2,073 |
void () { super.visitEnd(); }
|
visitEnd
|
2,074 |
void (String name) { addUsage(new ClassUsage(name)); }
|
visitClassType
|
2,075 |
int () { return super.hashCode() + 2; }
|
hashCode
|
2,076 |
boolean () { return getFlags().isTransitive(); }
|
isTransitive
|
2,077 |
String () { return myVersion; }
|
getVersion
|
2,078 |
boolean (DiffCapable<?, ?> other) { return other instanceof ModuleRequires && getName().equals(((ModuleRequires)other).getName()); }
|
isSame
|
2,079 |
int () { return getName().hashCode(); }
|
diffHashCode
|
2,080 |
Diff (ModuleRequires past) { return new Diff(past); }
|
difference
|
2,081 |
boolean () { return super.unchanged() && !versionChanged(); }
|
unchanged
|
2,082 |
boolean () { return !Objects.equals(myPast.getVersion(), getVersion()); }
|
versionChanged
|
2,083 |
boolean () { return myPast.getFlags().isTransitive() && !getFlags().isTransitive(); }
|
becameNonTransitive
|
2,084 |
int () { return super.hashCode() + 1; }
|
hashCode
|
2,085 |
JvmNodeReferenceID () { return myOwner; }
|
getElementOwner
|
2,086 |
boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final JvmElementUsage jvmUsage = (JvmElementUsage)o; if (!myOwner.equals(jvmUsage.myOwner)) { return false; } return true; }
|
equals
|
2,087 |
int () { return myOwner.hashCode(); }
|
hashCode
|
2,088 |
String () { return myName; }
|
getName
|
2,089 |
boolean (Object o) { if (!super.equals(o)) { return false; } final MemberUsage that = (MemberUsage)o; if (!myName.equals(that.myName)) { return false; } return true; }
|
equals
|
2,090 |
int () { int result = super.hashCode(); result = 31 * result + myName.hashCode(); return result; }
|
hashCode
|
2,091 |
boolean (DifferentiateContext context, Node<?, ?> affectedNode) { if (affectedNode instanceof JvmClass && ((JvmClass)affectedNode).getFlags().isGenerated()) { // If among affected files are annotation processor-generated, then we might need to re-generate them. // To achieve this, we need to recompile the whole chunk which will cause processors to re-generate these affected files debug("Turning non-incremental for the BuildTarget because dependent class is annotation-processor generated: ", affectedNode.getReferenceID()); return false; } return true; }
|
isIncremental
|
2,092 |
boolean (DifferentiateContext context, Iterable<Node<?, ?>> nodesBefore, Iterable<Node<?, ?>> nodesAfter) { Utils future = new Utils(context.getGraph(), context.getDelta()); Utils present = new Utils(context.getGraph(), null); Difference.Specifier<JvmClass, JvmClass.Diff> classesDiff = Difference.deepDiff( Graph.getNodesOfType(nodesBefore, JvmClass.class), Graph.getNodesOfType(nodesAfter, JvmClass.class) ); if (!Iterators.isEmpty(classesDiff.removed())) { debug("Processing removed classes:"); for (JvmClass removed : classesDiff.removed()) { debug("Adding usages of class ", removed.getName()); context.affectUsage(new ClassUsage(removed.getReferenceID())); } debug("End of removed classes processing."); } if (!processAddedClasses(context, classesDiff, future, present)) { return false; } Iterable<Difference.Change<JvmClass, JvmClass.Diff>> changed = classesDiff.changed(); if (!Iterators.isEmpty(changed)) { debug("Processing changed classes:"); try { for (Difference.Change<JvmClass, JvmClass.Diff> change : changed) { if (!processChangedClass(context, change, future, present)) { return false; } } } finally { debug("End of changed classes processing"); } } Difference.Specifier<JvmModule, JvmModule.Diff> modulesDiff = Difference.deepDiff( Graph.getNodesOfType(nodesBefore, JvmModule.class), Graph.getNodesOfType(nodesAfter, JvmModule.class) ); if (!processModules(context, modulesDiff, future, present)) { return false; } return true; }
|
differentiate
|
2,093 |
boolean (DifferentiateContext context, Difference.Specifier<JvmClass, JvmClass.Diff> classesDiff, Utils future, Utils present) { Iterable<JvmClass> addedClasses = classesDiff.added(); if (Iterators.isEmpty(addedClasses)) { return true; } debug("Processing added classes:"); BackDependencyIndex index = context.getGraph().getIndex(ClassShortNameIndex.NAME); assert index != null; // affecting dependencies on all other classes with the same short name Set<ReferenceID> affectedNodes = new HashSet<>(); for (JvmClass addedClass : addedClasses){ debug("Class name: ", addedClass.getName()); // class duplication checks if (!addedClass.isAnonymous() && !addedClass.isLocal() && addedClass.getOuterFqName().isEmpty()) { Set<NodeSource> deletedSources = context.getDelta().getDeletedSources(); Predicate<? super NodeSource> belongsToChunk = context.getParams().belongsToCurrentCompilationChunk(); Set<NodeSource> candidates = Iterators.collect( Iterators.filter(present.getNodeSources(addedClass.getReferenceID()), s -> !deletedSources.contains(s) && belongsToChunk.test(s)), new HashSet<>() ); if (!Iterators.isEmpty(Iterators.filter(candidates, src -> !context.isCompiled(src)))) { Iterators.collect(context.getDelta().getSources(addedClass.getReferenceID()), candidates); final StringBuilder msg = new StringBuilder(); msg.append("Possibly duplicated classes in the same compilation chunk; Scheduling for recompilation sources: "); for (NodeSource candidate : candidates) { context.affectNodeSource(candidate); msg.append(candidate.getPath()).append("; "); } debug(msg.toString()); continue; // if duplicates are found, do not perform further checks for classes with the same short name } } if (!addedClass.isAnonymous() && !addedClass.isLocal()) { Iterators.collect(index.getDependencies(new JvmNodeReferenceID(addedClass.getShortName())), affectedNodes); affectedNodes.add(addedClass.getReferenceID()); } } for (ReferenceID id : Iterators.unique(Iterators.flat(Iterators.map(affectedNodes, id -> context.getGraph().getDependingNodes(id))))) { affectNodeSources(context, id, "Affecting dependencies on class with the same short name: " + id + " ", true); } debug("End of added classes processing."); return true; }
|
processAddedClasses
|
2,094 |
boolean (DifferentiateContext context, Difference.Change<JvmClass, JvmClass.Diff> change, Utils future, Utils present) { JvmClass changedClass = change.getPast(); JvmClass.Diff classDiff = change.getDiff(); if (classDiff.superClassChanged() || classDiff.signatureChanged() || !classDiff.interfaces().unchanged()) { boolean extendsChanged = classDiff.superClassChanged() && !classDiff.extendsAdded(); boolean affectUsages = classDiff.signatureChanged() || extendsChanged || !Iterators.isEmpty(classDiff.interfaces().removed()); affectSubclasses(context, future, change.getNow().getReferenceID(), affectUsages); if (extendsChanged) { TypeRepr.ClassType exClass = new TypeRepr.ClassType(changedClass.getName()); for (JvmClass depClass : Iterators.flat(Iterators.map(context.getGraph().getDependingNodes(changedClass.getReferenceID()), dep -> present.getNodes(dep, JvmClass.class)))) { for (JvmMethod method : depClass.getMethods()) { if (Iterators.contains(method.getExceptions(), exClass)) { context.affectUsage(method.createUsage(depClass.getReferenceID())); debug("Affecting usages of methods throwing ", exClass.getJvmName(), " exception; class ", depClass.getName()); } } } } if (!changedClass.isAnonymous()) { Set<JvmNodeReferenceID> parents = Iterators.collect(present.allSupertypes(changedClass.getReferenceID()), new HashSet<>()); parents.removeAll(Iterators.collect(future.allSupertypes(changedClass.getReferenceID()), new HashSet<>())); for (JvmNodeReferenceID parent : parents) { debug("Affecting usages in generic type parameter bounds of class: ", parent); context.affectUsage(new ClassAsGenericBoundUsage(parent)); // todo: need support of file-filter usage constraint? } } } JVMFlags addedFlags = classDiff.getAddedFlags(); if (addedFlags.isInterface() || classDiff.getRemovedFlags().isInterface()) { debug("Class-to-interface or interface-to-class conversion detected, added class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); } if (changedClass.isAnnotation() && changedClass.getRetentionPolicy() == RetentionPolicy.SOURCE) { debug("Annotation, retention policy = SOURCE => a switch to non-incremental mode requested"); if (!affectOnNonIncrementalChange(context, changedClass.getReferenceID(), changedClass, present)) { debug("End of Differentiate, returning false"); return false; } } if (addedFlags.isProtected()) { debug("Introduction of 'protected' modifier detected, adding class usage + inheritance constraint to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID()), new InheritanceConstraint(future, changedClass)); } if (!changedClass.getFlags().isPackageLocal() && change.getNow().getFlags().isPackageLocal()) { debug("Introduction of 'package-private' access detected, adding class usage + package constraint to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID()), new PackageConstraint(changedClass.getPackageName())); } if (addedFlags.isFinal() || addedFlags.isPrivate()) { debug("Introduction of 'private' or 'final' modifier(s) detected, adding class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); } if (addedFlags.isAbstract() || addedFlags.isStatic()) { debug("Introduction of 'abstract' or 'static' modifier(s) detected, adding class new usage to affected usages"); context.affectUsage(new ClassNewUsage(changedClass.getReferenceID())); } if (!changedClass.isAnonymous() && !changedClass.isPrivate() && classDiff.flagsChanged() && changedClass.isInnerClass()) { debug("Some modifiers (access flags) were changed for non-private inner class, adding class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); } if (changedClass.isAnnotation()) { debug("Class is annotation, performing annotation-specific analysis"); if (classDiff.retentionPolicyChanged()) { debug("Retention policy change detected, adding class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); } else if (classDiff.targetAttributeCategoryMightChange()) { debug("Annotation's attribute category in bytecode might be affected because of TYPE_USE or RECORD_COMPONENT target, adding class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); } else { Difference.Specifier<ElemType, ?> targetsDiff = classDiff.annotationTargets(); Set<ElemType> removedTargets = Iterators.collect(targetsDiff.removed(), EnumSet.noneOf(ElemType.class)); if (removedTargets.contains(ElemType.LOCAL_VARIABLE)) { debug("Removed target contains LOCAL_VARIABLE => a switch to non-incremental mode requested"); if (!affectOnNonIncrementalChange(context, changedClass.getReferenceID(), changedClass, present)) { debug("End of Differentiate, returning false"); return false; } } if (!removedTargets.isEmpty()) { debug("Removed some annotation targets, adding annotation query"); TypeRepr.ClassType classType = new TypeRepr.ClassType(changedClass.getName()); context.affectUsage((node, usage) -> { if (usage instanceof AnnotationUsage) { AnnotationUsage annotUsage = (AnnotationUsage)usage; if (classType.equals(annotUsage.getClassType())) { for (ElemType target : annotUsage.getTargets()) { if (removedTargets.contains(target)) { return true; } } } } return false; }); } for (JvmMethod m : classDiff.methods().added()) { if (m.getValue() == null) { debug("Added method with no default value: ", m.getName()); debug("Adding class usage to affected usages"); context.affectUsage(new ClassUsage(changedClass.getReferenceID())); break; } } } debug("End of annotation-specific analysis"); } if (!processMethodChanges(context, change, future, present)) { return false; } if (!processFieldChanges(context, change, future, present)) { return false; } return true; }
|
processChangedClass
|
2,095 |
boolean (DifferentiateContext context, Difference.Change<JvmClass, JvmClass.Diff> classChange, Utils future, Utils present) { JvmClass changedClass = classChange.getPast(); Difference.Specifier<JvmMethod, JvmMethod.Diff> methodsDiff = classChange.getDiff().methods(); if (!changedClass.isAnnotation()) { processAddedMethods(context, changedClass, methodsDiff.added(), future, present); } else { debug("Class is annotation, skipping method analysis for added methods"); } processRemovedMethods(context, changedClass, methodsDiff.removed(), future, present); processChangedMethods(context, changedClass, methodsDiff.changed(), future, present); return true; }
|
processMethodChanges
|
2,096 |
void (DifferentiateContext context, JvmClass changedClass, Iterable<Difference.Change<JvmMethod, JvmMethod.Diff>> changed, Utils future, Utils present) { debug("Processing changed methods: "); if (changedClass.isInterface()) { for (Difference.Change<JvmMethod, JvmMethod.Diff> change : Iterators.filter(changed, ch -> ch.getDiff().getRemovedFlags().isAbstract())) { debug("Method became non-abstract: ", change.getPast().getName()); affectLambdaInstantiations(context, present, changedClass.getReferenceID()); break; } } for (Difference.Change<JvmMethod, JvmMethod.Diff> change : changed) { JvmMethod changedMethod = change.getPast(); JvmMethod.Diff diff = change.getDiff(); if (diff.unchanged()) { continue; } debug("Method: ", changedMethod.getName()); if (changedClass.isAnnotation()) { if (diff.valueRemoved()) { debug("Class is annotation, default value is removed => adding annotation query"); String argName = changedMethod.getName(); TypeRepr.ClassType annotType = new TypeRepr.ClassType(changedClass.getName()); context.affectUsage((node, usage) -> { if (usage instanceof AnnotationUsage) { // need to find annotation usages that do not use arguments this annotation uses AnnotationUsage au = (AnnotationUsage)usage; return annotType.equals(au.getClassType()) && Iterators.isEmpty(Iterators.filter(au.getUsedArgNames(), argName::equals)); } return false; }); } continue; } Iterable<JvmNodeReferenceID> propagated = Iterators.lazy(() -> future.collectSubclassesWithoutMethod(changedClass.getReferenceID(), changedMethod)); if (diff.becamePackageLocal()) { debug("Method became package-private, affecting method usages outside the package"); affectMemberUsages(context, changedClass.getReferenceID(), changedMethod, propagated, new PackageConstraint(changedClass.getPackageName())); } if (diff.typeChanged() || diff.signatureChanged() || !diff.exceptions().unchanged()) { debug("Return type, throws list or signature changed --- affecting method usages"); affectMemberUsages(context, changedClass.getReferenceID(), changedMethod, propagated); for (JvmNodeReferenceID subClass : Iterators.unique(Iterators.map(future.getOverridingMethods(changedClass, changedMethod, changedMethod::isSameByJavaRules), p -> p.getFirst().getReferenceID()))) { affectNodeSources(context, subClass, "Affect source file of a class which overrides the changed method: "); } } else if (diff.flagsChanged()) { JVMFlags addedFlags = diff.getAddedFlags(); JVMFlags removedFlags = diff.getRemovedFlags(); if (addedFlags.isStatic() || addedFlags.isPrivate() || addedFlags.isSynthetic() || addedFlags.isBridge() || removedFlags.isStatic()) { // When synthetic or bridge flags are added, this effectively means that explicitly written in the code // method with the same signature and return type has been removed and a bridge method has been generated instead. // In some cases (e.g. using raw types) the presence of such synthetic methods in the bytecode is ignored by the compiler // so that the code that called such method via raw type reference might not compile anymore => to be on the safe side // we should recompile all places where the method was used debug("Added {static | private | synthetic | bridge} specifier or removed static specifier --- affecting method usages"); affectMemberUsages(context, changedClass.getReferenceID(), changedMethod, propagated); if (addedFlags.isStatic()) { debug("Added static specifier --- affecting subclasses"); affectSubclasses(context, future, changedClass.getReferenceID(), false); if (!changedMethod.isPrivate()) { debug("Added static modifier --- affecting static member on-demand import usages"); affectStaticMemberOnDemandUsages(context, changedClass.getReferenceID(), propagated); } } else if (removedFlags.isStatic()) { if (!changedMethod.isPrivate()) { debug("Removed static modifier --- affecting static method import usages"); affectStaticMemberImportUsages(context, changedClass.getReferenceID(), changedMethod.getName(), propagated); } } } else { if (addedFlags.isFinal() || addedFlags.isPublic() || addedFlags.isAbstract()) { debug("Added final, public or abstract specifier --- affecting subclasses"); affectSubclasses(context, future, changedClass.getReferenceID(), false); if (changedClass.isInterface() && addedFlags.isAbstract()) { affectLambdaInstantiations(context, present, changedClass.getReferenceID()); } } if (addedFlags.isProtected() && !removedFlags.isPrivate()) { debug("Added public or package-private method became protected --- affect method usages with protected constraint"); affectMemberUsages(context, changedClass.getReferenceID(), changedMethod, propagated, new InheritanceConstraint(future, changedClass)); } } } // todo: do we need to support AnnotationChangeTracker in the new implementation? Looks like its functionality transforms into kotlin-specific rules //Difference.Specifier<TypeRepr.ClassType, ?> annotationsDiff = diff.annotations(); //if (!annotationsDiff.unchanged()) { //} } Iterable<Difference.Change<JvmMethod, JvmMethod.Diff>> moreAccessible = Iterators.collect(Iterators.filter(changed, ch -> ch.getDiff().accessExpanded()), new SmartList<>()); if (!Iterators.isEmpty(moreAccessible)) { Iterable<OverloadDescriptor> overloaded = findAllOverloads(future, changedClass, method -> { JVMFlags mostAccessible = null; for (var change : moreAccessible) { JvmMethod m = change.getNow(); if (Objects.equals(m.getName(), method.getName()) && !m.isSame(method)) { if (mostAccessible == null || mostAccessible.isWeakerAccess(m.getFlags())) { mostAccessible = m.getFlags(); } } } return mostAccessible; }); for (OverloadDescriptor descr : overloaded) { debug("Method became more accessible --- affect usages of overloading methods: ", descr.overloadMethod.getName()); Predicate<Node<?, ?>> constr = descr.accessScope.isPackageLocal()? new PackageConstraint(changedClass.getPackageName()).negate() : descr.accessScope.isProtected()? new InheritanceConstraint(future, changedClass).negate() : null; affectMemberUsages(context, descr.owner, descr.overloadMethod, future.collectSubclassesWithoutMethod(descr.owner, descr.overloadMethod), constr); } } debug("End of changed methods processing"); }
|
processChangedMethods
|
2,097 |
Iterable<OverloadDescriptor> (Utils utils, final JvmClass cls, Function<? super JvmMethod, JVMFlags> correspondenceFinder) { Function<JvmClass, Iterable<OverloadDescriptor>> mapper = c -> Iterators.filter(Iterators.map(c.getMethods(), m -> { JVMFlags accessScope = correspondenceFinder.apply(m); return accessScope != null? new OverloadDescriptor(accessScope, m, c.getReferenceID()) : null; }), Iterators.notNullFilter()); return Iterators.flat( Iterators.flat(Iterators.map(Iterators.recurse(cls, cl -> Iterators.flat(Iterators.map(cl.getSuperTypes(), st -> utils.getClassesByName(st))), true), cl -> mapper.apply(cl))), Iterators.flat(Iterators.map(utils.allSubclasses(cls.getReferenceID()), id -> Iterators.flat(Iterators.map(utils.getNodes(id, JvmClass.class), cl1 -> mapper.apply(cl1))))) ); }
|
findAllOverloads
|
2,098 |
void (DifferentiateContext context, JvmClass changedClass, Iterable<JvmMethod> removed, Utils future, Utils present) { debug("Processing removed methods: "); boolean extendsLibraryClass = future.inheritsFromLibraryClass(changedClass); // todo: lazy? for (JvmMethod removedMethod : removed) { debug("Method ", removedMethod.getName()); Iterable<JvmNodeReferenceID> propagated = Iterators.lazy(() -> future.collectSubclassesWithoutMethod(changedClass.getReferenceID(), removedMethod)); if (!removedMethod.isPrivate() && removedMethod.isStatic()) { debug("The method was static --- affecting static method import usages"); affectStaticMemberImportUsages(context, changedClass.getReferenceID(), removedMethod.getName(), propagated); } if (removedMethod.isPackageLocal()) { // Sometimes javac cannot find an overridden package local method in superclasses, when superclasses are defined in different packages. // This results in compilation error when the code is compiled from the very beginning. // So even if we correctly find a corresponding overridden method and the bytecode compatibility remains, // we still need to affect package local method usages to behave similar to javac. debug("Removed method is package-local, affecting method usages"); affectMemberUsages(context, changedClass.getReferenceID(), removedMethod, propagated); } else { Iterable<Pair<JvmClass, JvmMethod>> overridden = Iterators.lazy(() -> removedMethod.isConstructor()? Collections.emptyList() : future.getOverriddenMethods(changedClass, removedMethod::isSameByJavaRules)); boolean isClearlyOverridden = removedMethod.getSignature().isEmpty() && !extendsLibraryClass && !Iterators.isEmpty(overridden) && Iterators.isEmpty( Iterators.filter(overridden, p -> !p.getSecond().getType().equals(removedMethod.getType()) || !p.getSecond().getSignature().isEmpty() || removedMethod.isMoreAccessibleThan(p.getSecond())) ); if (!isClearlyOverridden) { debug("No overridden methods found, affecting method usages"); affectMemberUsages(context, changedClass.getReferenceID(), removedMethod, propagated); } } for (Pair<JvmClass, JvmMethod> overriding : future.getOverridingMethods(changedClass, removedMethod, removedMethod::isSameByJavaRules)) { affectNodeSources(context, overriding.getFirst().getReferenceID(), "Affecting file by overriding: "); } if (!removedMethod.isConstructor() && !removedMethod.isAbstract() && !removedMethod.isStatic()) { for (JvmNodeReferenceID id : propagated) { for (JvmClass subClass : future.getNodes(id, JvmClass.class)) { Iterable<Pair<JvmClass, JvmMethod>> overriddenForSubclass = Iterators.filter(future.getOverriddenMethods(subClass, removedMethod::isSameByJavaRules), p -> p.getSecond().isAbstract() || removedMethod.isSame(p.getSecond())); boolean allOverriddenAbstract = !Iterators.isEmpty(overriddenForSubclass) && Iterators.isEmpty(Iterators.filter(overriddenForSubclass, p -> !p.getSecond().isAbstract())); if (allOverriddenAbstract || future.inheritsFromLibraryClass(subClass)) { debug("Removed method is not abstract & overrides some abstract method which is not then over-overridden in subclass ", subClass.getName()); affectNodeSources(context, subClass.getReferenceID(), "Affecting subclass source file: "); } break; } } } } debug("End of removed methods processing"); }
|
processRemovedMethods
|
2,099 |
void (DifferentiateContext context, JvmClass changedClass, Iterable<JvmMethod> added, Utils future, Utils present) { debug("Processing added methods: "); for (JvmMethod addedMethod : added) { if (!addedMethod.isPrivate() && (changedClass.isInterface() || changedClass.isAbstract() || addedMethod.isAbstract())) { debug("Method: " + addedMethod.getName()); debug("Class is abstract, or is interface, or added non-private method is abstract => affecting all subclasses"); affectSubclasses(context, future, changedClass.getReferenceID(), false); break; } } if (changedClass.isInterface()) { for (JvmMethod addedMethod : added) { if (!addedMethod.isPrivate() && addedMethod.isAbstract()) { debug("Added non-private abstract method: ", addedMethod.getName()); affectLambdaInstantiations(context, present, changedClass.getReferenceID()); break; } } } for (JvmMethod addedMethod : added) { debug("Method: ", addedMethod.getName()); if (addedMethod.isPrivate()) { continue; } Iterable<JvmNodeReferenceID> propagated = Iterators.lazy(() -> future.collectSubclassesWithoutMethod(changedClass.getReferenceID(), addedMethod)); if (!Iterators.isEmpty(addedMethod.getArgTypes()) && !present.hasOverriddenMethods(changedClass, addedMethod)) { debug("Conservative case on overriding methods, affecting method usages"); context.affectUsage(addedMethod.createUsageQuery(changedClass.getReferenceID())); if (!addedMethod.isConstructor()) { // do not propagate constructors access, since constructors are always concrete and not accessible via references to subclasses for (JvmNodeReferenceID id : propagated) { context.affectUsage(new AffectionScopeMetaUsage(id)); context.affectUsage(addedMethod.createUsageQuery(id)); } } } if (addedMethod.isStatic()) { affectStaticMemberOnDemandUsages(context, changedClass.getReferenceID(), propagated); } Predicate<JvmMethod> lessSpecificCond = future.lessSpecific(addedMethod); for (JvmMethod lessSpecific : Iterators.filter(changedClass.getMethods(), lessSpecificCond::test)) { debug("Found less specific method, affecting method usages; ", lessSpecific.getName(), lessSpecific.getDescriptor()); affectMemberUsages(context, changedClass.getReferenceID(), lessSpecific, present.collectSubclassesWithoutMethod(changedClass.getReferenceID(), lessSpecific)); } debug("Processing affected by specificity methods"); for (Pair<JvmClass, JvmMethod> pair : future.getOverriddenMethods(changedClass, lessSpecificCond)) { JvmClass cls = pair.getFirst(); JvmMethod overriddenMethod = pair.getSecond(); // isInheritor(cls, changedClass) == false debug("Method: ", overriddenMethod.getName()); debug("Class : ", cls.getName()); debug("Affecting method usages for that found"); affectMemberUsages(context, changedClass.getReferenceID(), overriddenMethod, present.collectSubclassesWithoutMethod(changedClass.getReferenceID(), overriddenMethod)); } for (Pair<JvmClass, JvmMethod> pair : future.getOverridingMethods(changedClass, addedMethod, lessSpecificCond)) { JvmClass cls = pair.getFirst(); JvmMethod overridingMethod = pair.getSecond(); // isInheritor(cls, changedClass) == true debug("Method: ", overridingMethod.getName()); debug("Class : ", cls.getName()); if (overridingMethod.isSameByJavaRules(addedMethod)) { debug("Current method overrides the added method"); affectNodeSources(context, cls.getReferenceID(), "Affecting source "); } else { debug("Current method does not override the added method"); debug("Affecting method usages for the method"); affectMemberUsages(context, cls.getReferenceID(), overridingMethod, present.collectSubclassesWithoutMethod(cls.getReferenceID(), overridingMethod)); } } for (ReferenceID subClassId : future.allSubclasses(changedClass.getReferenceID())) { Iterable<NodeSource> sources = context.getGraph().getSources(subClassId); if (!Iterators.isEmpty(Iterators.filter(sources, s -> !context.isCompiled(s)))) { // has non-compiled sources for (JvmClass outerClass : Iterators.flat(Iterators.map(future.getNodes(subClassId, JvmClass.class), cl -> future.getNodes(new JvmNodeReferenceID(cl.getOuterFqName()), JvmClass.class)))) { if (future.isMethodVisible(outerClass, addedMethod) || future.inheritsFromLibraryClass(outerClass)) { for (NodeSource source : Iterators.filter(sources, context.getParams().affectionFilter()::test)) { debug("Affecting file due to local overriding: ", source.getPath()); context.affectNodeSource(source); } } } } } } debug("End of added methods processing"); }
|
processAddedMethods
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.