Fix HBM-AEAddon Build Failure: A Comprehensive Guide

Aug 8, 2025 by Pedro Alvarez 53 views

Build Failure Discussion: HBM-AEAddon Gradle Build Error

Introduction

Encountering build failures is a common challenge in software development, especially when working with complex projects and build systems like Gradle. This article delves into a specific build failure encountered while working on the HBM-AEAddon project, providing a comprehensive analysis of the error, its causes, and potential solutions. Guys, let's break down this issue step by step to get your build back on track!

The initial error message indicates a problem during the spotlessJava task, which is part of the code formatting process. The core issue is that the project is running Spotless on Java Virtual Machine (JVM) 8, which limits the version of google-java-format to 1.7. To resolve this, the error message suggests upgrading the JVM to version 11 or higher, which would allow the use of google-java-format 1.15.0, potentially fixing the problem. This upgrade is crucial because newer versions of google-java-format may include fixes for parsing errors or other issues that are causing the build to fail.

Additionally, the error log highlights a deprecation notice regarding the support for running Gradle using Java versions older than 21. While this doesn't directly cause the immediate build failure, it's an important warning to heed. The project should consider upgrading its Java version for Gradle to 21 or newer to ensure long-term compatibility and avoid potential issues in the future. This doesn't necessarily mean that the mod code itself needs to use Java 21; the Gradle process can use Java 21 while the compiler and mod code can remain on Java 8 if needed.

The error log also mentions a critical requirement for version control using Git. The project must be under Git version control, and the repository should have at least one Git tag. This is essential for versioning the mod and ensuring proper tracking of changes. If Git-based versioning isn't desired, the gtnh.modules.gitVersion property in the gradle.properties file can be set to false, and the project.ext.modVersion property can be populated with a valid string in the build script. This allows for a custom versioning mechanism if needed.

Detailed Error Analysis

To dive deeper into the issue, let's dissect the error message and the Gradle build process. The error trace points to the spotlessJava task failing due to an exception within the removeUnusedImports step. This step uses google-java-format to automatically format the Java code and remove unused imports. The error message “You are running Spotless on JVM 8, which limits you to google-java-format 1.7” clearly indicates the root cause. The older version of google-java-format may not be compatible with certain code constructs or may have bugs that are causing it to fail.

The stack trace provides further insights into the error. It shows that the exception originates from the com.diffplug.spotless.java.GoogleJavaFormatStep class, specifically within the constructRemoveUnusedFunction method. This method is responsible for creating a function that removes unused imports from the Java code. The underlying cause of the exception is a com.google.googlejavaformat.java.FormatterException with the message “66:41: error: ')' expected”. This suggests that the google-java-format tool encountered a syntax error in the src\main\java\com\glodblock\github\hbmaeaddon\client\gui\GuiHBMFluidExposer.java file, specifically around line 66, column 41, where a closing parenthesis was expected but not found. This could be due to a variety of reasons, such as a typo, an incomplete statement, or a bug in the google-java-format tool itself.

Troubleshooting Steps and Solutions

Based on the error analysis, here are the key steps to troubleshoot and resolve this build failure. These steps are designed to address both the immediate error and potential long-term issues:

Upgrade JVM for Gradle: The most straightforward solution is to upgrade the JVM used for running Gradle to version 11 or higher. This will allow the project to use a newer version of google-java-format, which may have fixed the parsing error. To do this, you need to ensure that you have a compatible JDK installed (e.g., JDK 11, JDK 17, or JDK 21) and configure Gradle to use it. This can be done by setting the org.gradle.java.home property in the gradle.properties file or by setting the JAVA_HOME environment variable.
```
org.gradle.java.home=C:/path/to/jdk17
```
Alternatively, you can set the JAVA_HOME environment variable to the path of your desired JDK.
Inspect the Code: Examine the src\main\java\com\glodblock\github\hbmaeaddon\client\gui\GuiHBMFluidExposer.java file, specifically around line 66, column 41, for any syntax errors or inconsistencies. Look for missing parentheses, incorrect operators, or any other potential issues that could cause the google-java-format tool to fail. Correcting these syntax errors may resolve the FormatterException.
Check google-java-format Version: Verify the version of google-java-format being used by the project. If upgrading the JVM doesn't automatically update the google-java-format version, you may need to explicitly specify the desired version in your build.gradle file. Ensure that the version you are using is compatible with your code and doesn't have known issues.
```
dependencies {
    spotless("com.google.googlejavaformat:google-java-format:1.15.0")
}
```
Git Versioning: Ensure that the project is under Git version control and that at least one Git tag exists. This is crucial for the project's versioning mechanism. If you are not using Git, you can disable Git-based versioning by setting gtnh.modules.gitVersion = false in your gradle.properties file and populating project.ext.modVersion with a valid string in your build script.
Clean and Rebuild: After making any changes, perform a clean build to ensure that all previous build artifacts are removed. This can be done by running the ./gradlew clean build command. Cleaning the build ensures that any cached files or outdated dependencies are removed, preventing potential conflicts or issues.
Run with Stacktrace: If the build continues to fail, run the Gradle build with the --stacktrace option to get a more detailed error message. This will provide a complete stack trace, which can help pinpoint the exact location and cause of the error.
```
./gradlew build --stacktrace
```
Run with Info or Debug: For even more detailed output, you can run the build with the --info or --debug option. This will provide additional log messages that can help you understand what Gradle is doing and identify any potential issues.
```
./gradlew build --info
./gradlew build --debug
```
Consult the FAQ: The error log mentions that you might want to check out ./gradlew :faq if your build fails. This command may provide additional information or troubleshooting steps specific to your project or environment.

Code Example and Explanation

Let's take a closer look at a hypothetical code snippet that might cause the FormatterException. Suppose the GuiHBMFluidExposer.java file contains the following code:

public class GuiHBMFluidExposer extends GuiContainer {

    private final TileEntityHBMFluidExposer tileEntity;

    public GuiHBMFluidExposer(InventoryPlayer inventoryPlayer, TileEntityHBMFluidExposer tileEntity) {
        super(new ContainerHBMFluidExposer(inventoryPlayer, tileEntity));
        this.tileEntity = tileEntity;
    }

    @Override
    protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
        String name = I18n.format(tileEntity.getDisplayName().getFormattedText());
        fontRenderer.drawString(name, xSize / 2 - fontRenderer.getStringWidth(name) / 2, 6, 4210752);
    
        // Missing closing parenthesis here
        drawFluidTank(tileEntity.getTank(), 8, 16, 52, 68;
    }

    @Override
    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        this.mc.getTextureManager().bindTexture(TEXTURE_GUI);
        int i = (this.width - this.xSize) / 2;
        int j = (this.height - this.ySize) / 2;
        this.drawTexturedModalRect(i, j, 0, 0, this.xSize, this.ySize);
    }
}

In this example, the drawFluidTank method call in the drawGuiContainerForegroundLayer method is missing a closing parenthesis. This syntax error would cause the google-java-format tool to fail with the “')' expected” error. Correcting this error by adding the missing parenthesis would likely resolve the build failure.

Deprecation Notice and Long-Term Maintenance

The deprecation notice regarding the use of older Java versions with Gradle is an important consideration for the long-term maintenance of the project. While upgrading the JVM for Gradle might seem like a simple fix, it's essential to understand the implications and plan accordingly.

Why is this important?

Compatibility: Gradle is continuously evolving, and newer versions may drop support for older Java versions. Using a deprecated Java version can lead to compatibility issues in the future.
Performance: Newer Java versions often include performance improvements and optimizations that can enhance the build process.
Security: Older Java versions may have security vulnerabilities that are addressed in newer releases.

How to address the deprecation notice:

Upgrade Java: As recommended in the error message, upgrade your local and CI workflow Java version to 21 or newer. This ensures that you are using a supported and up-to-date Java version for Gradle.
Mod Code Compatibility: Ensure that your mod code remains compatible with the target Java version for your mod. You can use different Java versions for the Gradle process and the mod code compilation.
Testing: After upgrading Java, thoroughly test your build process and mod to ensure that everything is working as expected.

Conclusion

Build failures can be frustrating, but understanding the error messages and the underlying processes can help you resolve them efficiently. In this case, the build failure in the HBM-AEAddon project was caused by running Spotless on JVM 8, which limited the google-java-format version and resulted in a parsing error. By upgrading the JVM for Gradle, inspecting the code for syntax errors, and ensuring proper version control, you can resolve this issue and get your build back on track. Remember, guys, keeping your tools and dependencies up-to-date is crucial for a smooth development process and the long-term health of your project.

By following these steps and understanding the error messages, you can effectively troubleshoot and resolve build failures, ensuring a smoother development experience for your projects. If you have any further questions or need additional assistance, don't hesitate to seek help from the community or consult the relevant documentation. Happy coding!