Dead Code Elimination in Go

Dead code elimination is a crucial optimization technique in compilers. It involves identifying and removing code that has no effect on the program's output. This challenge asks you to implement a simplified dead code elimination pass for Go code, focusing on unreachable code blocks within functions.

Problem Description

You are tasked with creating a function eliminateDeadCode that takes a string representing Go code as input and returns a string with unreachable code blocks removed. Unreachable code blocks are those that cannot be reached by any execution path within a function. This typically includes code after a return, panic, or os.Exit statement, or code within an else block when the corresponding if condition is always true. The goal is to improve code clarity and potentially reduce the size of the compiled binary.

Key Requirements:

• Function Signature: The function must accept a string (Go code) and return a string (modified Go code).
• Unreachable Code Detection: Identify code blocks that are unreachable due to return, panic, os.Exit, or else statements following an if statement where the condition is always true (simplified condition checking - see Notes).
• Code Removal: Remove the unreachable code blocks from the input string.
• Preservation of Valid Code: Ensure that only unreachable code is removed; valid, reachable code must be preserved.
• Basic Syntax Handling: The code should handle basic Go syntax, including function definitions, if statements, else statements, return, panic, and os.Exit. More complex Go features (e.g., loops, complex expressions) are outside the scope of this challenge.

Expected Behavior:

The function should parse the input Go code, identify unreachable code blocks, and return a modified version of the code with those blocks removed. The output should still be valid Go code.

Edge Cases to Consider:

• Empty input string.
• Functions with no code.
• Multiple return, panic, or os.Exit statements within a function.
• Nested if statements.
• Comments within the code.
• Code after a return statement.
• else blocks following if statements where the condition is always true (e.g., if false { ... } else { ... }).

Examples

Example 1:

Input:
```go
func foo() {
    return
    fmt.Println("This will never be printed")
}

Output:

func foo() {
    return
}

Explanation: The fmt.Println statement is unreachable after the return statement.

Example 2:

Input:
```go
func bar() {
    if false {
        fmt.Println("This will never be printed")
    } else {
        fmt.Println("This will be printed")
    }
}

Output:

func bar() {
    fmt.Println("This will be printed")
}

Explanation: The code within the if block is unreachable because the condition is always false. The else block is reachable.

Example 3:

Input:
```go
func baz() {
    panic("Something went wrong")
    fmt.Println("This will never be printed")
}

Output:

func baz() {
    panic("Something went wrong")
}

Explanation: The fmt.Println statement is unreachable after the panic statement.

Constraints

• Input String Length: The input string representing Go code can be up to 1000 characters.
• Code Complexity: The Go code will be relatively simple, focusing on function definitions, if/else statements, return, panic, and os.Exit. Complex control flow structures (loops, switch statements) are not expected.
• Performance: The solution should be reasonably efficient. While a full-fledged compiler pass is not required, avoid excessively slow algorithms. A time complexity of O(n) where n is the length of the input string is desirable.
• Error Handling: The function does not need to handle invalid Go syntax. Assume the input is syntactically correct Go code.

Notes

• Simplified Condition Checking: For the purpose of this challenge, assume that checking for always-true conditions in if statements is simplified. You can assume that if the condition is a literal false, the if block is unreachable. More complex condition evaluations are not required.
• String Manipulation: You can use string manipulation techniques (e.g., splitting, searching, replacing) to implement the dead code elimination pass.
• No External Libraries: Do not use external libraries for parsing or code analysis. The solution should be self-contained.
• Focus on Unreachability: The primary focus is on removing unreachable code blocks. Do not attempt to perform other optimizations.
• Whitespace: Preserve whitespace as much as possible to maintain code readability.
• Comments: Comments should be preserved. Do not remove comments.
• os.Exit: Code after os.Exit is always unreachable.