Home /Modules/tests/java_flow_021_semantics.cpp

java_flow_021_semantics.cpp

tests/java_flow_021_semantics.cpp · 89 line(s) · c

#include "../impl/frontend/java/java_flow.h"
#include <cassert>
#include <iostream>
using namespace sleela;

static JavaFlowExpr lit(bool v) { JavaFlowExpr e; e.kind=JavaFlowExprKind::Literal; e.op=v?"true":"false"; return e; }
static JavaFlowExpr var(const char* n) { JavaFlowExpr e; e.kind=JavaFlowExprKind::Variable; e.name=n; return e; }
static JavaFlowExpr bin(const char* op, JavaFlowExpr a, JavaFlowExpr b) { JavaFlowExpr e; e.kind=JavaFlowExprKind::Binary; e.op=op; e.children={a,b}; return e; }
static JavaFlowExpr un(const char* op, JavaFlowExpr a) { JavaFlowExpr e; e.kind=JavaFlowExprKind::Unary; e.op=op; e.children={a}; return e; }
static JavaFlowStmt decl(const char* n) { JavaFlowStmt s; s.kind=JavaFlowStmtKind::LocalDeclaration; s.variable=n; return s; }
static JavaFlowStmt assign(const char* n) { JavaFlowStmt s; s.kind=JavaFlowStmtKind::Assignment; s.variable=n; return s; }
static JavaFlowStmt read(const char* n) { JavaFlowStmt s; s.kind=JavaFlowStmtKind::Expression; s.expression=var(n); return s; }
static bool has(const JavaFlowResult& r, JavaFlowDiagnosticKind k) { for (const auto& d:r.diagnostics) if(d.kind==k) return true; return false; }

int main() {
    // Short-circuit paths: assignment on the RHS of && is known only on true.
    JavaFlowExpr rhsAssign; rhsAssign.kind=JavaFlowExprKind::Assignment;
    rhsAssign.children={var("x"),lit(true)};
    auto andExpr=bin("&&",lit(true),rhsAssign);
    JavaFlowStmt use; use.kind=JavaFlowStmtKind::Expression; use.expression=andExpr;
    auto r1=analyzeJavaFlow({decl("x"),use});
    assert(!has(r1,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // ! reverses directional flow without changing the source facts.
    JavaFlowExpr notExpr=un("!",lit(false));
    JavaFlowStmt ifs; ifs.kind=JavaFlowStmtKind::If; ifs.condition=notExpr; ifs.children={assign("x")};
    auto r2=analyzeJavaFlow({decl("x"),ifs,read("x")});
    assert(has(r2,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // A constant-true loop has no normal condition-false exit.
    JavaFlowStmt loop; loop.kind=JavaFlowStmtKind::While; loop.condition=lit(true);
    loop.children={assign("x")};
    auto r3=analyzeJavaFlow({decl("x"),loop});
    assert(!r3.after.reachable);

    // A matching break is a normal exit path from the loop.
    JavaFlowStmt br; br.kind=JavaFlowStmtKind::Break;
    loop.children={assign("x"),br};
    auto r4=analyzeJavaFlow({decl("x"),loop,read("x")});
    assert(!has(r4,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // Basic-for initialization/update are traversed; an update read of an
    // unassigned variable must be diagnosed even though update is not an exit.
    JavaFlowStmt forStmt; forStmt.kind=JavaFlowStmtKind::For;
    JavaFlowStmt fi=decl("i"); fi.hasInitializer=true; fi.expression=lit(true);
    forStmt.forInitialization={fi};
    forStmt.condition=lit(false);
    forStmt.forUpdate={var("missing")};
    auto r5a=analyzeJavaFlow({forStmt});
    assert(!has(r5a,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // A continue path reaches the update component before the next condition.
    JavaFlowStmt fc; fc.kind=JavaFlowStmtKind::Continue;
    JavaFlowStmt fl; fl.kind=JavaFlowStmtKind::For; fl.condition=lit(true);
    fl.children={fc}; fl.forUpdate={var("missing2")};
    auto r5b=analyzeJavaFlow({fl});
    assert(has(r5b,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // A labeled block accepts break but not continue.
    JavaFlowStmt lb; lb.kind=JavaFlowStmtKind::Labeled; lb.label="outer";
    JavaFlowStmt bad; bad.kind=JavaFlowStmtKind::Continue; bad.label="outer";
    lb.children={bad};
    auto r5=analyzeJavaFlow({lb});
    assert(has(r5,JavaFlowDiagnosticKind::InvalidContinue));

    // An unlabeled continue outside a loop is invalid.
    JavaFlowStmt bad2; bad2.kind=JavaFlowStmtKind::Continue;
    auto r6=analyzeJavaFlow({bad2});
    assert(has(r6,JavaFlowDiagnosticKind::InvalidContinue));


    // Loop fixed-point: a condition-false path must not inherit assignments
    // from a body that never executes.
    JavaFlowStmt never; never.kind=JavaFlowStmtKind::While; never.condition=lit(false);
    never.children={assign("neverAssigned")};
    auto r7=analyzeJavaFlow({decl("neverAssigned"),never,read("neverAssigned")});
    assert(has(r7,JavaFlowDiagnosticKind::UseBeforeAssignment));

    // Definite-unassignment is preserved through a single guaranteed final
    // assignment followed by a matching break.
    JavaFlowStmt finalDecl=decl("finalValue"); finalDecl.finalVariable=true;
    JavaFlowStmt finalLoop; finalLoop.kind=JavaFlowStmtKind::While; finalLoop.condition=lit(true);
    finalLoop.children={assign("finalValue"),br};
    auto r8=analyzeJavaFlow({finalDecl,finalLoop,read("finalValue")});
    assert(!has(r8,JavaFlowDiagnosticKind::FinalReassignment));
    std::cout<<"java directional-flow/control-target tests passed\n";
    return 0;
}