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 has a clear, single responsibility: representing a long integer literal. The structure is logical with a standard constructor, getter, and overridden methods. Nesting is minimal—there are no conditional blocks or loops. Intent is explicit through descriptive method names and a clear class-level Javadoc comment. The code is concise, with no redundant statements. Action granularity is appropriate, with one meaningful operation per line. The reading flow is natural: class declaration, field, constructor, then overridden methods in a sensible order. Minor deductions might be for a slight lack of inline comments explaining descriptor values, but overall it is an exemplary piece of clean code.
Run 3
The code is highly readable. It follows a clear, logical structure with a single class definition and well-organized methods. Nesting is minimal—only one class and no conditional or loop structures, keeping the code flat. Intent is clear: the class represents a long integer literal in an expression language AST, as stated in the Javadoc. The code is concise, with no unnecessary lines or redundancy. Each method performs a single, coherent action (get literal value, check compilability, generate bytecode), and each main action is on its own line. Reading flow is natural—imports, class declaration, field, constructor, then overridden methods in a logical order. Variable names are descriptive (payload, startPos, endPos, value, exitTypeDescriptor). The only minor issue is that the Javadoc author and version tags are not included, but this does not materially affect readability.
Run 1
Code Structure: Well-organized class with a single field, constructor, and clearly separated overridden methods. Nesting: Minimal; no conditional or loop nesting. Clarity of intent: Class documentation, descriptive names, and straightforward methods clearly communicate its role as a long-literal AST node. The JVM descriptor "J" and bytecode visitor call require domain knowledge. Code length: Concise, with no unnecessary logic; extra blank lines are a minor formatting issue. Action granularity: Each statement performs one action on its own line. Reading flow: Natural progression from initialization to value access, compilation capability, and code generation.
Run 2
Code Structure: A logically organized class with one field, a constructor, and focused overrides. Nesting: Completely flat method bodies make it easy to follow. Clarity of intent: The class documentation and descriptive names clearly identify a long-literal AST node; the JVM descriptor "J" and bytecode API require some domain knowledge. Code length: Concise, with no unnecessary logic, though extra blank lines add minor visual spacing. Action granularity: Each statement performs one distinct action on its own line. Reading flow: The progression from initialization to value retrieval, compilation capability, and code generation is natural and consistent.
Run 3
Code Structure: The class is logically organized into a single field, constructor, and focused overridden methods. Nesting: There is no nested control flow, making every method easy to scan. Clarity of intent: The class name, documentation, and method names clearly communicate its role as a long-literal AST node; the descriptor "J" and abbreviation "mv" require some JVM familiarity. Code length: The implementation is concise, with no unnecessary logic, though a few extra blank lines add minor visual spacing. Action granularity: Each statement performs one clear action. Reading flow: The progression from initialization to value access, compilability, and code generation is natural and consistent.