Function TestCheckRuleNegative

analysis/validation_test.go:192–242

(t *testing.T)

}

func TestCheckRuleNegative(t *testing.T) {
	tests := []ast.Clause{
		clause("foo(X)."),
		clause("foo(_)."),
		clause("foo(_) :- bar(_)."),
		clause("foo(X, _) :- foo(2, 1)."),
		clause("foo(X) :- bar(Y)."),
		clause("foo(X) :- X != Y, bar(Y)."),
		clause("foo(X) :- X = Y."),
		clause("foo(X) :- X < Y, foo(Y)."),
		clause("foo(X) :- X = [Y]."),
		clause("foo(X) :- X = fn:list(Y)."),
		clause("foo(X) :- X = fn:list:get(1)."),
		clause("foo(X) :- X = fn:list(fn:list:get(1))."),
		clause("foo(X) :- X = fn:list(_)."),
		// Head variable neither defined by body nor transform.
		clause("foo(A) :- bar(X) |> let Y = fn:plus(X, X)."),
		// Wildcard is like a variable neither defined by body nor transform.
		clause("foo(Y) :- bar(X) |> let Y = fn:plus(X, _)."),
		// Transform variable not defined by body.
		clause("foo(Y) :- bar(X) |> do fn:group_by(A)."),
		// Wildcard is like a variable not defined by body.
		clause("foo(Y) :- bar(X) |> do fn:group_by(_)."),
		// Wildcard references do not make sense in a transform.
		clause("foo(Y) :- bar(X) |> let Y = fn:plus(X, X), let Z = fn:ring_the_alarm(_)."),
		// A transform may not redefine a variable from body.
		clause("foo(X) :- bar(X) |> let X = fn:plus(X, X)."),
		// Wrong arity
		clause("foo(Y) :- bar(X) |> let Y = fn:list:get(1)."),
		// fn:collect() needs at least one argument.
		clause("foo(X) :- bar(Y) |> do fn:group_by(), let X = fn:collect()."),
		// fn:collect_distinct() needs at least one argument.
		clause("foo(X) :- bar(Y) |> do fn:group_by(), let X = fn:collect_distinct()."),
		// In a reducer, need to refer to variables from body.
		clause("foo(X) :- bar(Y), baz(Z) |> do fn:group_by(Y), let X = fn:collect(X)."),
		// nonsensical uses of fn:struct and fn:map
		clause("foo(X) :- X = fn:struct(1)."),
		clause("foo(X) :- X = fn:struct(1,2,3)."),
		clause("foo(X) :- X = fn:map(1)."),
		clause("foo(X) :- X = fn:map(1,2,3)."),
		clause("foo(A) :- bar(Y), bar(Z) |> do fn:group_by(Y), let A = fn:plus(Z, 1)."),
	}
	for _, clause := range tests {
		analyzer, _ := New(map[ast.PredicateSym]ast.Decl{
			ast.PredicateSym{"bar", 1}: makeSyntheticDecl(t, atom("bar(X)")),
		}, nil, ErrorForBoundsMismatch)
		if err := analyzer.CheckRule(clause); err == nil {
			t.Errorf("Expected error for rule %v", clause)
		}
	}
}

func mustDesugar(t *testing.T, decls map[ast.PredicateSym]ast.Decl) map[ast.PredicateSym]*ast.Decl {
	t.Helper()