Go if-else — Professional / Internals Level¶

// This Go code:
func abs(n int) int {
    if n < 0 {
        return -n
    }
    return n
}

// Becomes this AST (simplified):
// IfStmt {
//     Cond: BinaryExpr { X: n, Op: <, Y: 0 }
//     Body: BlockStmt { ReturnStmt { UnaryExpr { Op: -, X: n } } }
//     Else: nil
// }
// ReturnStmt { X: n }

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

// Likely compiled to CMOV (branchless):
func clamp(v, lo, hi int) int {
    if v < lo { v = lo }
    if v > hi { v = hi }
    return v
}

// NOT compiled to CMOV (side effects):
func processOrSkip(x int) {
    if x > 0 {
        expensiveOp(x)  // has side effects — must branch
    }
}

func expensiveOp(x int) {}

// Does NOT escape (stays on stack)
func processLocal(flag bool) int {
    x := 42
    if flag {
        x = -x
    }
    return x  // returned by value, no escape
}

// ESCAPES to heap (returned as pointer)
func processEscaping(flag bool) *int {
    x := 42
    if flag {
        x = -x
    }
    return &x  // x escapes: compiler moves to heap
}

// Interface boxing causes escape
func processInterface(flag bool) interface{} {
    x := 42
    if flag {
        return x  // boxing: x escapes to heap
    }
    return nil
}

// Pre-allocated avoids repeated escape
var cachedResult = 42

func processPreallocated(flag bool) *int {
    if flag {
        return &cachedResult  // pointer to static — no allocation
    }
    return nil
}

package main

import (
    "runtime"
    "testing"
)

// Allocation-heavy: creates garbage every call
func heavyBranch(err error) string {
    if err != nil {
        return fmt.Sprintf("error: %v", err)  // allocation!
    }
    return "ok"
}

// GC-friendly: pre-computed strings, no allocation
const okStr = "ok"

func lightBranch(err error) string {
    if err != nil {
        return err.Error()  // may or may not allocate
    }
    return okStr  // no allocation: constant string
}

func BenchmarkHeavy(b *testing.B) {
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        heavyBranch(nil)
    }
}

func BenchmarkLight(b *testing.B) {
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        lightBranch(nil)
    }
}

var _ = runtime.GC // keep import

// Valid per spec:
if x := 5; x > 0 {}             // SimpleStmt + Expression + Block
if x > 0 {}                      // Expression + Block only
if x > 0 {} else {}              // with else Block
if x > 0 {} else if y > 0 {}    // with else IfStmt

// Invalid per spec:
// if x > 0 { } else             // else with no block
// if (x > 0) { }                // parentheses are redundant but VALID

// After lexing, the parser sees:
if condition {
    doThis()
};          // <-- semicolon inserted after }
else {      // ERROR: unexpected else after statement
    doThat()
}

// Correct: else on same line — no semicolon inserted
if condition {
    doThis()
} else {    // } followed by else — no semicolon
    doThat()
}

// Simplified version of what the scanner does
func (s *scanner) insertSemi(tok token) bool {
    switch tok {
    case _Name, _Literal, _Break, _Continue,
         _Fallthrough, _Return, _Inc, _Dec,
         _Rparen, _Rbracket, _Rbrace:
        return true
    }
    return false
}

package main

import (
    "go/ast"
    "go/parser"
    "go/token"
    "fmt"
)

func main() {
    src := `
package main
func f() {
    if x > 0 {
        return 1
    } else {
        return 0
    }
}`

    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", src, 0)
    if err != nil {
        panic(err)
    }

    // Walk the AST to find if statements
    ast.Inspect(f, func(n ast.Node) bool {
        if ifStmt, ok := n.(*ast.IfStmt); ok {
            fmt.Printf("IfStmt at %v\n", fset.Position(ifStmt.Pos()))
            fmt.Printf("  Condition: %T\n", ifStmt.Cond)
            fmt.Printf("  Body statements: %d\n", len(ifStmt.Body.List))
            if ifStmt.Else != nil {
                fmt.Printf("  Has else: %T\n", ifStmt.Else)
            }
            if ifStmt.Init != nil {
                fmt.Printf("  Has init: %T\n", ifStmt.Init)
            }
        }
        return true
    })
}

type IfStmt struct {
    If   token.Pos  // position of "if" keyword
    Init Stmt       // initialization statement (may be nil)
    Cond Expr       // condition (always non-nil; MUST be bool)
    Body *BlockStmt // "if" body
    Else Stmt       // else branch (may be nil)
}

// Simplified from cmd/compile/internal/types2/stmt.go
func (check *Checker) stmt(inner stmtContext, s syntax.Stmt) {
    switch s := s.(type) {
    case *syntax.IfStmt:
        // Check init statement
        if s.Init != nil {
            check.stmt(inner, s.Init)
        }
        // Check condition MUST be bool
        var x operand
        check.expr(&x, s.Cond)
        if x.mode != invalid {
            check.assignment(&x, Typ[Bool], "condition")
        }
        // Check body
        check.stmtList(inner, s.Then.List)
        // Check else
        if s.Else != nil {
            check.stmt(inner|elseContext, s.Else)
        }
    }
}

package main

import (
    "go/ast"
    "go/parser"
    "go/token"
    "fmt"
)

// Count if statements in source code
func countIfStatements(src string) int {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", src, 0)
    if err != nil {
        return -1
    }

    count := 0
    ast.Inspect(f, func(n ast.Node) bool {
        if _, ok := n.(*ast.IfStmt); ok {
            count++
        }
        return true
    })
    return count
}

// Extract all conditions from if statements
func extractConditions(src string) []string {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", src, 0)
    if err != nil {
        return nil
    }

    var conditions []string
    ast.Inspect(f, func(n ast.Node) bool {
        if ifStmt, ok := n.(*ast.IfStmt); ok {
            // Format the condition as string
            conditions = append(conditions,
                fmt.Sprintf("%T", ifStmt.Cond))
        }
        return true
    })
    return conditions
}

func main() {
    src := `package main
func f(x, y int) {
    if x > 0 { }
    if x > 0 && y > 0 { }
    if err := doSomething(); err != nil { }
}`

    fmt.Println("If count:", countIfStatements(src))
    for _, c := range extractConditions(src) {
        fmt.Println("Condition type:", c)
    }
}

func doSomething() error { return nil }

// Step 1: Build instrumented binary
go build -o app .

// Step 2: Run with profiling
// app produces cpu.pprof via runtime/pprof

// Step 3: Build with PGO
go build -pgo=cpu.pprof -o app_pgo .

// Concrete devirtualization example
var w io.Writer = os.Stdout  // interface

// In hot path: PGO may detect w is always *os.File and optimize
if err != nil {
    fmt.Fprintln(w, err)  // may be devirtualized to direct call
}