Source code
package org.springframework.expression.spel.ast;
import org.springframework.asm.MethodVisitor;
import org.springframework.expression.TypedValue;
import org.springframework.expression.spel.CodeFlow;
/**
* Expression language AST node that represents a long integer literal.
*
* @author Andy Clement
* @since 3.0
*/
public class LongLiteral extends Literal {
private final TypedValue value;
public LongLiteral(String payload, int startPos, int endPos, long value) {
super(payload, startPos, endPos);
this.value = new TypedValue(value);
this.exitTypeDescriptor = "J";
}
@Override
public TypedValue getLiteralValue() {
return this.value;
}
@Override
public boolean isCompilable() {
return true;
}
@Override
public void generateCode(MethodVisitor mv, CodeFlow cf) {
mv.visitLdcInsn(this.value.getValue());
cf.pushDescriptor(this.exitTypeDescriptor);
}
}
Run 1
The code is highly readable. It has a clear, logical structure with a single class, well-named fields, and a straightforward constructor. Nesting is minimal; there are no deeply nested control structures. The intent of each method is explicit: retrieving the literal value, checking compilability, and generating bytecode. Code length is concise and appropriate for the functionality. Action granularity is sensible, with one logical action per line in the generateCode method. Reading flow is natural, with the class definition, field, constructor, and methods arranged in a conventional order. Minor deductions would only reflect the lack of explicit null or bounds checks, but for a literal AST node this is acceptable and idiomatic.
Run 2
The code is highly readable. It is well-structured, with clear package and imports, and a single class that extends a base literal type. Each method is focused and performs one action, such as returning a value, checking compilability, or generating code. Nesting is minimal, and the logic is flat with no deep conditional blocks. Naming is clear and follows Java conventions, making the intent obvious. The class is concise, with no unnecessary code or comments. The reading flow is natural, moving from field declaration to constructor to overridden methods. The only minor deduction is for the repeated use of 'this.' which is slightly verbose but still clear.
Run 3
The code is highly readable. It has a clear, single-purpose class structure with logical organization: fields, constructor, then overridden methods. Nesting is flat and minimal. Intent is unambiguous—it represents a long integer literal in an expression AST. Code length is concise without unnecessary boilerplate. Action granularity is appropriate, with one logical action per line. Reading flow is natural, starting from class documentation through field declaration, constructor initialization, and method implementations. Minor deductions: lack of JavaDoc on methods (though overrides are self-explanatory) and no explicit validation of payload/value consistency, but these are trivial. Overall, the code exemplifies clean, maintainable design.
Run 1
Code Structure: The class is logically organized into a field, constructor, and focused overridden methods. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: The class documentation, descriptive names, and straightforward methods clearly convey its purpose as a long-literal AST node; the JVM descriptor "J" requires some domain knowledge. Code length: The implementation is concise, with no unnecessary logic, though extra blank lines add minor visual padding. Action granularity: Each statement performs one clear action on its own line. Reading flow: The progression from initialization to value retrieval, compilability, and bytecode generation is natural and consistent.
Run 2
Code Structure: The class is logically organized, with one field, a constructor, and focused overridden methods. Nesting: All methods are flat, with no conditional or loop nesting. Clarity of intent: The documentation, class name, and method names clearly convey a long-literal AST node; the descriptor "J" and abbreviation "mv" require some JVM bytecode knowledge. Code length: The implementation is concise, without unnecessary logic or duplication. Action granularity: Each statement performs a single clear action on its own line. Reading flow: The progression from initialization to value access, compilation capability, and code generation is natural. Extra blank lines are a minor formatting distraction.
Run 3
Code Structure: The class is logically organized into a field, constructor, and clearly separated overridden methods. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: The class documentation and method names clearly communicate its role as a long-integer literal AST node; the descriptor "J" and abbreviation "mv" require some domain knowledge. Code length: The implementation is concise, with no unnecessary logic. Action granularity: Each statement occupies its own line and performs a distinct operation. Reading flow: The sequence from initialization to value retrieval, compilation capability, and code generation is natural. Minor excess blank lines do not materially affect readability.