Why does a list of values not cool on the LLVM backend of K? - kframework

Question

When trying to define the syntax for a Scheme-like language, I found that the running result of kompiled file with java backend
kompile --backend java scheme.k -d .
behaves differently with llvm backend
kompile --backend llvm scheme.k -d .
Here's my code for scheme.k:
module SCHEME-COMMON
imports DOMAINS-SYNTAX
syntax Name ::= "+" | "-" | "*" | "/"
| "display" | "newline"
syntax Names ::= List{Name," "}
syntax Exp ::= Int | Bool | String | Name
| "[" Name Exps "]" [strict(2)]
syntax Exps ::= List{Exp," "} [strict]
syntax Val
syntax Vals ::= List{Val," "}
syntax Bottom
syntax Bottoms ::= List{Bottom," "}
syntax Pgm ::= Exp Pgm [strict(1)]
| "eof"
endmodule
module SCHEME-SYNTAX
imports SCHEME-COMMON
imports BUILTIN-ID-TOKENS
syntax Name ::= r"[a-z][_a-zA-Z0-9]*" [token, prec(2)]
| #LowerId [token]
endmodule
module SCHEME-MACROS
imports SCHEME-COMMON
endmodule
module SCHEME
imports SCHEME-COMMON
imports SCHEME-MACROS
imports DOMAINS
configuration <T color="yellow">
<k color="green"> $PGM:Pgm </k>
<env color="violet"> .Map </env>
<store color="white"> .Map </store>
<input color="magenta" stream="stdin"> .List </input>
<output color="brown" stream="stdout"> .List </output>
</T>
syntax Val ::= Int | Bool | String
syntax Exp ::= Val
syntax Exps ::= Vals
syntax Vals ::= Bottoms
syntax Exps ::= Names
syntax Names ::= Bottoms
syntax KResult ::= Vals | Val
rule _:Val P:Pgm => P
when notBool(P ==K eof)
rule V:Val eof => V
rule [+ I1 I2 Vals] => [+ (I1 +Int I2) Vals] [arith]
rule [+ I .Vals] => I [arith]
rule [- I1 I2 Vals] => [- (I1 -Int I2) Vals] [arith]
rule [- I .Vals] => I [arith]
rule [* I1 I2 Vals] => [* (I1 *Int I2) Vals] [arith]
rule [* I .Vals] => I [arith]
rule [/ I1 I2 Vals] => [/ (I1 /Int I2) Vals]
when I2 =/=K 0 [arith]
rule [/ I .Vals] => I [arith]
rule <k> [newline .Exps] => "" ...</k>
<output>... .List => ListItem("\n") </output> [io]
rule <k> [display V:Val] => "" ...</k>
<output>... .List => ListItem(V) </output> [io]
endmodule
and this is the test file I'm trying to run:
[display 8]
eof
Strangely, the kompiled version using java can run this test case normally, while the kompiled version using llvm stucks at
<k>
8 .Bottoms ~> #freezer[__]_SCHEME-COMMON_Exp_Name_Exps0_ ( display ) ~> #freezer___SCHEME-COMMON_Pgm_Exp_Pgm1_ ( eof )
</k>
What might be a possible reason? The version information for kompile is
RV-K version 1.0-SNAPSHOT
Git revision: a7c2937
Git branch: UNKNOWN
Build date: Wed Feb 12 09:46:03 CST 2020

Answer 1

In the LLVM and Haskell backends, two productions are said to overload with one another when they share the same arity and klabel attribute and all the argument sorts of one production are less than or equal to the argument sorts of the other, and the result sort of the first is less than the result of the other. Special consideration is given during matching to terms that overload: For example, in your example, if a list of Exps and a list of Vals were said to overload, then if you have a pattern V:Vals, it would match the term V:Val, .Exps of sort Exps.
By default, the Java backend assumes that all Lists between sorts that have a subsort relationship overload. However, the LLVM and Haskell backends do not make this assumption. Thus, your example will work if you give the same klabel attribute to your Exps List and your Vals list. We do not do the same thing in the llvm backend because we have found that it tends to lead to serious ambiguity in your grammar in places where you do not expect it.
For example:
module SCHEME-COMMON
imports DOMAINS-SYNTAX
syntax Name ::= "+" | "-" | "*" | "/"
| "display" | "newline"
syntax Names ::= List{Name," "} [klabel(exps)]
syntax Exp ::= Int | Bool | String | Name
| "[" Name Exps "]" [strict(2)]
syntax Exps ::= List{Exp," "} [strict, klabel(exps)]
syntax Val
syntax Vals ::= List{Val," "} [klabel(exps)]
syntax Bottom
syntax Bottoms ::= List{Bottom," "} [klabel(exps)]
syntax Pgm ::= Exp Pgm [strict(1)]
| "eof"
endmodule