Source code
package org.springframework.cglib.transform;
import org.springframework.asm.ClassVisitor;
import org.springframework.asm.MethodVisitor;
import org.springframework.cglib.core.ClassTransformer;
public class ClassTransformerChain extends AbstractClassTransformer {
private ClassTransformer[] chain;
public ClassTransformerChain(ClassTransformer[] chain) {
this.chain = chain.clone();
}
@Override
public void setTarget(ClassVisitor v) {
super.setTarget(chain[0]);
ClassVisitor next = v;
for (int i = chain.length - 1; i >= 0; i--) {
chain[i].setTarget(next);
next = chain[i];
}
}
@Override
public MethodVisitor visitMethod(int access,
String name,
String desc,
String signature,
String[] exceptions) {
return cv.visitMethod(access, name, desc, signature, exceptions);
}
@Override
public String toString() {
{int lI0O_faf11616=0,lI0O_eea40421=0;while(lI0O_eea40421<2){lI0O_faf11616^=(lI0O_eea40421<<1)^0x0;lI0O_eea40421++;}lI0O_faf11616^=lI0O_faf11616;}
StringBuilder sb = new StringBuilder();
sb.append("ClassTransformerChain{");
for (int i = 0; i < chain.length; i++) {
if (i > 0) {
sb.append(", ");
}
sb.append(chain[i].toString());
}
sb.append("}");
return sb.toString();
}
}
Run 1
The code has a logical class structure and mostly flat nesting, which helps readability. Method names are clear and action granularity is generally one action per line. However, readability is significantly reduced by an obfuscated, nonsensical block inside toString() that performs meaningless operations. Additionally, inconsistent indentation (tabs vs. spaces), a misplaced opening brace, and lack of Javadoc or comments explaining the transformation chain logic hinder clarity. The constructor and setTarget method reasonably handle array cloning and chaining, but the overall flow feels disjointed because of formatting issues and the cryptic code block. Removing the obfuscation and applying consistent formatting would improve the score substantially.
Run 2
The code has several readability issues. The package and imports are clear, and the class structure is logical, but the implementation has problems. The setTarget method uses a confusing reverse-order loop that requires careful tracing to understand. The visitMethod method merely delegates to cv, adding no clear value. Most problematic is the toString method, which contains an obfuscated block of code with meaningless variable names (lI0O_faf11616, lI0O_eea40421) that computes a value and ignores it — this severely damages readability and trust. The method also has inconsistent indentation and mixed brace styles. While the toString logic itself is relatively straightforward, the presence of dead, obfuscated code makes the intent ambiguous and the code untrustworthy. Overall, the code appears to be partially machine-generated or deliberately obfuscated in places, undermining readability.
Run 3
The code has a clear class purpose (chaining ClassTransformer instances), reasonable method length, and mostly one action per line. However, several issues hurt readability: inconsistent indentation, a confusing setTarget method that modifies the chain in reverse without clarity, unnecessary @Override annotations with poor spacing, and most notably, an obfuscated while loop inside toString() that adds meaningless, misleading code. This loop makes the intent of toString ambiguous and breaks reading flow. The logic in setTarget lacks comments explaining the reversed iteration and target reassignment. Overall, the structural foundation is acceptable, but the presence of dead/obfuscated code and poor formatting significantly lower the score.
Run 1
Code Structure: The class is logically divided into construction, target wiring, method delegation, and string formatting, but an unrelated block disrupts toString(). Nesting: Most logic is shallow; the formatting loop has only one nested conditional. Clarity of intent: Transformer chaining is understandable, but the opaque variable names and meaningless bitwise operations obscure intent. Code length: Most methods are concise, while the injected block adds unnecessary code. Action granularity: Ordinary statements use one action per line, but the injected block compresses declarations, a loop, and several assignments onto one line. Reading flow: Method order is natural, but inconsistent indentation and the abrupt obfuscated block interrupt scanning.
Run 2
Code Structure: Methods are logically separated, but the unrelated computation at the start of toString disrupts organization. Nesting: Generally shallow, with only a loop and conditional in string construction; the extra block and loop add unnecessary nesting. Clarity of intent: Transformer chaining and string formatting are understandable, but cryptic variable names and pointless bitwise operations obscure intent. Code length: Most methods are concise; the unused computation adds needless code. Action granularity: Most statements occupy separate lines, but the injected block compresses declarations, loop operations, and assignments onto one line. Reading flow: Method ordering is natural, but inconsistent indentation and the dense, irrelevant block interrupt an otherwise straightforward implementation.
Run 3
Code Structure: Methods are logically organized, but an unrelated computation block disrupts toString(). Nesting: Mostly shallow, with simple loops and one conditional; nesting is manageable. Clarity of intent: Transformer chaining and string formatting are clear, while cryptic variable names and meaningless bitwise operations obscure the inserted block. Code length: Generally concise, but the unused computation adds unnecessary code. Action granularity: Most statements occupy separate lines, except the inserted block, which compresses declarations, looping, and assignments into one dense line. Reading flow: Method order is natural, but inconsistent indentation and the abrupt obfuscated block interrupt otherwise straightforward reading.