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 follows a clear, logical structure with the class definition, field declaration, constructor, and overridden methods in a natural order. Nesting is minimal — only one level of indentation is used within the class body. The intent is unambiguous: it represents a long integer literal node in a SpEL AST, with a concise constructor, a getter for the literal value, and methods for compilation behavior. Code length is minimal and appropriate, with no redundant logic. Action granularity is excellent — each line performs a single, focused action, such as assigning a TypedValue or pushing a descriptor. Reading flow is natural, moving from state to initialization to behavior. Javadoc and clear method names further enhance clarity, making the code easy to understand at a glance.
Run 3
The code is highly readable. It has a clear, single-purpose class structure representing a long literal in an expression language AST. The constructor is straightforward, initializing fields and calling the superclass. Methods are short and focused: getLiteralValue returns the stored value, isCompilable returns a constant, and generateCode performs two clear operations. Nesting is minimal, with no conditional or loop constructs. Each line performs a single action, and the reading flow is natural—from field declarations to constructor to overridden methods. The only minor deduction is the lack of comments within generateCode, though the method name and surrounding context make its intent clear. The code is concise, well-organized, and follows common conventions, making it easy to understand at a glance.
Run 1
Code Structure: Logically organized into a field, constructor, and focused overridden methods. Nesting: Flat, with no conditionals or loops. Clarity of intent: The class documentation, descriptive names, and straightforward methods clearly identify a long-literal AST node; the JVM descriptor "J" and bytecode API calls require some domain knowledge. Code length: Concise, with no unnecessary implementation. Action granularity: Each statement performs one clear action on its own line. Reading flow: Natural progression from initialization to value access, compilation capability, and code generation. Minor formatting issues, including extra blank lines and no separation between the package declaration and imports, slightly reduce polish.
Run 2
Code Structure: Well-organized class with a field, constructor, and clearly separated overrides. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive class and method names, supported by documentation, make the long-literal representation clear; the descriptor "J" and abbreviated parameters require some JVM/framework knowledge. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs one action on its own line. Reading flow: Natural progression from initialization to value access and code generation; minor excess blank lines do not significantly affect readability.
Run 3
Code Structure: The class is logically organized into a field, constructor, and small 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 convey its role as a long-literal AST node; the JVM descriptor "J" and abbreviated parameters mv and cf require some domain knowledge. Code length: The implementation is concise with no unnecessary logic, although extra blank lines add minor visual space. Action granularity: Each statement performs one distinct action. Reading flow: Initialization precedes value access and compilation behavior, creating a natural progression.