balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactoring of the parsers

Browse Source 
* [CameLIGO/ReasonLIGO] The AST node [EAnnot] (expressions
    annotated by a type) now records the region in the source
    code for the colon.

  * [CameLIGO/ReasonLIGO/PascaLIGO] I added the syntax
     %token <...> TOKEN "lexeme"

  * [ReasonLIGO] I changed the AST nodes [Mtz] and [Str] to
    [Mutez] and [String], respectively (in accordance with the
    PascaLIGO front-end). I changed token [DOTDOTDOT] to
    [ELLIPSIS].

  * [ReasonLIGO] I added what was missing to make a loca build
    with my Makefile.
This commit is contained in:
Christian Rinderknecht 2019-12-15 17:46:08 +01:00
parent 6692643cc5
commit f8d6396fcd
21 changed files with 1196 additions and 1522 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/passes/1-parser/cameligo/.Parser.ml.tag
View File

@ -1 +0,0 @@
ocamlc: -w -42-40

2
src/passes/1-parser/cameligo/AST.ml
View File

@ -226,7 +226,7 @@ and field_pattern = {
and expr = and expr =
ECase of expr case reg ECase of expr case reg
| ECond of cond_expr reg | ECond of cond_expr reg
| EAnnot of (expr * type_expr) reg | EAnnot of (expr * colon * type_expr) par reg
| ELogic of logic_expr | ELogic of logic_expr
| EArith of arith_expr | EArith of arith_expr
| EString of string_expr | EString of string_expr

2
src/passes/1-parser/cameligo/AST.mli
View File

@ -214,7 +214,7 @@ and field_pattern = {
and expr = and expr =
ECase of expr case reg (* p1 -> e1 | p2 -> e2 | ... *) ECase of expr case reg (* p1 -> e1 | p2 -> e2 | ... *)
| ECond of cond_expr reg (* if e1 then e2 else e3 *) | ECond of cond_expr reg (* if e1 then e2 else e3 *)
| EAnnot of (expr * type_expr) reg (* e : t *) | EAnnot of (expr * colon * type_expr) par reg (* (e : t) *)
| ELogic of logic_expr | ELogic of logic_expr
| EArith of arith_expr | EArith of arith_expr
| EString of string_expr | EString of string_expr

108
src/passes/1-parser/cameligo/ParToken.mly
View File

@ -5,76 +5,76 @@
(* Literals *) (* Literals *)
%token <string Region.reg> String %token <string Region.reg> String "<string>"
%token <(LexToken.lexeme * Hex.t) Region.reg> Bytes %token <(LexToken.lexeme * Hex.t) Region.reg> Bytes "<bytes>"
%token <(string * Z.t) Region.reg> Int %token <(string * Z.t) Region.reg> Int "<int>"
%token <(string * Z.t) Region.reg> Nat %token <(string * Z.t) Region.reg> Nat "<nat>"
%token <(string * Z.t) Region.reg> Mutez %token <(string * Z.t) Region.reg> Mutez "<mutez>"
%token <string Region.reg> Ident %token <string Region.reg> Ident "<ident>"
%token <string Region.reg> Constr %token <string Region.reg> Constr "<constr>"
(* Symbols *) (* Symbols *)
%token <Region.t> MINUS %token <Region.t> MINUS "-"
%token <Region.t> PLUS %token <Region.t> PLUS "+"
%token <Region.t> SLASH %token <Region.t> SLASH "/"
%token <Region.t> TIMES %token <Region.t> TIMES "*"
%token <Region.t> LPAR %token <Region.t> LPAR "("
%token <Region.t> RPAR %token <Region.t> RPAR ")"
%token <Region.t> LBRACKET %token <Region.t> LBRACKET "["
%token <Region.t> RBRACKET %token <Region.t> RBRACKET "]"
%token <Region.t> LBRACE %token <Region.t> LBRACE "{"
%token <Region.t> RBRACE %token <Region.t> RBRACE "}"
%token <Region.t> ARROW %token <Region.t> ARROW "->"
%token <Region.t> CONS %token <Region.t> CONS "::"
%token <Region.t> CAT %token <Region.t> CAT "^"
(*%token APPEND*) (*%token <Region.t> APPEND "@" *)
%token <Region.t> DOT %token <Region.t> DOT "."
%token <Region.t> COMMA %token <Region.t> COMMA ","
%token <Region.t> SEMI %token <Region.t> SEMI ";"
%token <Region.t> COLON %token <Region.t> COLON ":"
%token <Region.t> VBAR %token <Region.t> VBAR "|"
%token <Region.t> WILD %token <Region.t> WILD "_"
%token <Region.t> EQ %token <Region.t> EQ "="
%token <Region.t> NE %token <Region.t> NE "<>"
%token <Region.t> LT %token <Region.t> LT "<"
%token <Region.t> GT %token <Region.t> GT ">"
%token <Region.t> LE %token <Region.t> LE "<="
%token <Region.t> GE %token <Region.t> GE ">="
%token <Region.t> BOOL_OR %token <Region.t> BOOL_OR "||"
%token <Region.t> BOOL_AND %token <Region.t> BOOL_AND "&&"
(* Keywords *) (* Keywords *)
(*%token And*) (*%token And*)
%token <Region.t> Begin %token <Region.t> Begin "begin"
%token <Region.t> Else %token <Region.t> Else "else"
%token <Region.t> End %token <Region.t> End "end"
%token <Region.t> False %token <Region.t> False "false"
%token <Region.t> Fun %token <Region.t> Fun "fun"
%token <Region.t> If %token <Region.t> If "if"
%token <Region.t> In %token <Region.t> In "in"
%token <Region.t> Let %token <Region.t> Let "let"
%token <Region.t> Match %token <Region.t> Match "match"
%token <Region.t> Mod %token <Region.t> Mod "mod"
%token <Region.t> Not %token <Region.t> Not "not"
%token <Region.t> Of %token <Region.t> Of "of"
%token <Region.t> Or %token <Region.t> Or "or"
%token <Region.t> Then %token <Region.t> Then "then"
%token <Region.t> True %token <Region.t> True "true"
%token <Region.t> Type %token <Region.t> Type "type"
%token <Region.t> With %token <Region.t> With "with"
(* Data constructors *) (* Data constructors *)
%token <Region.t> C_None (* "None" *) %token <Region.t> C_None "None"
%token <Region.t> C_Some (* "Some" *) %token <Region.t> C_Some "Some"
(* Virtual tokens *) (* Virtual tokens *)

609
src/passes/1-parser/cameligo/Parser.mly
View File

@ -41,24 +41,10 @@ sep_or_term_list(item,sep):
(* Compound constructs *) (* Compound constructs *)
par(X): par(X):
LPAR X RPAR { "(" X ")" {
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {lpar=$1; inside=$2; rpar=$3}
lpar = $1; in {region; value} }
inside = $2;
rpar = $3}
in {region; value}
}
brackets(X):
LBRACKET X RBRACKET {
let region = cover $1 $3
and value = {
lbracket = $1;
inside = $2;
rbracket = $3}
in {region; value}
}
(* Sequences (* Sequences
@ -69,11 +55,8 @@ brackets(X):
latter returns a pair made of the first parsed item (the parameter latter returns a pair made of the first parsed item (the parameter
[X]) and the rest of the sequence (possibly empty). This way, the [X]) and the rest of the sequence (possibly empty). This way, the
OCaml typechecker can keep track of this information along the OCaml typechecker can keep track of this information along the
static control-flow graph. The rule [sepseq] parses possibly empty static control-flow graph. See module [Utils] for the types
sequences of items separated by some token (e.g., a comma), and corresponding to the semantic actions of those rules.
rule [nsepseq] is for non-empty such sequences. See module [Utils]
for the types corresponding to the semantic actions of those
rules.
*) *)
(* Possibly empty sequence of items *) (* Possibly empty sequence of items *)
@ -93,51 +76,36 @@ nsepseq(item,sep):
item { $1, [] } item { $1, [] }
| item sep nsepseq(item,sep) { let h,t = $3 in $1, ($2,h)::t } | item sep nsepseq(item,sep) { let h,t = $3 in $1, ($2,h)::t }
(* Possibly empy separated sequence of items *)
sepseq(item,sep):
(**) { None }
| nsepseq(item,sep) { Some $1 }
(* Helpers *) (* Helpers *)
%inline type_name : Ident { $1 } %inline type_name : "<ident>" { $1 }
%inline field_name : Ident { $1 } %inline field_name : "<ident>" { $1 }
%inline module_name : Constr { $1 } %inline struct_name : "<ident>" { $1 }
%inline struct_name : Ident { $1 } %inline module_name : "<constr>" { $1 }
(* Non-empty comma-separated values (at least two values) *) (* Non-empty comma-separated values (at least two values) *)
tuple(item): tuple(item):
item COMMA nsepseq(item,COMMA) { item "," nsepseq(item,",") { let h,t = $3 in $1,($2,h)::t }
let h,t = $3 in $1,($2,h)::t
}
(* Possibly empty semicolon-separated values between brackets *) (* Possibly empty semicolon-separated values between brackets *)
list(item): list(item):
LBRACKET sep_or_term_list(item,SEMI) RBRACKET { "[" sep_or_term_list(item,";")? "]" {
let elements, terminator = $2 in let compound = Brackets ($1,$3)
let value = { and region = cover $1 $3 in
compound = Brackets ($1,$3); let elements, terminator =
elements = Some elements; match $2 with
terminator} in None -> None, None
let region = cover $1 $3 | Some (elements, terminator) ->
in {value; region} Some elements, terminator in
} let value = {compound; elements; terminator}
| LBRACKET RBRACKET { in {region; value} }
let value = {
compound = Brackets ($1,$2);
elements = None;
terminator = None} in
let region = cover $1 $2
in {value; region}}
(* Main *) (* Main *)
contract: contract:
declarations EOF { declarations EOF { {decl=$1; eof=$2} }
{decl=$1; eof=$2} }
declarations: declarations:
declaration { $1,[] : AST.declaration Utils.nseq } declaration { $1,[] : AST.declaration Utils.nseq }
@ -150,7 +118,7 @@ declaration:
(* Type declarations *) (* Type declarations *)
type_decl: type_decl:
Type type_name EQ type_expr { "type" type_name "=" type_expr {
let region = cover $1 (type_expr_to_region $4) in let region = cover $1 (type_expr_to_region $4) in
let value = { let value = {
kwd_type = $1; kwd_type = $1;
@ -160,87 +128,72 @@ type_decl:
in {region; value} } in {region; value} }
type_expr: type_expr:
cartesian { $1 } cartesian | sum_type | record_type { $1 }
| sum_type { TSum $1 }
| record_type { TRecord $1 }
cartesian: cartesian:
fun_type TIMES nsepseq(fun_type,TIMES) { fun_type { $1 }
| fun_type "*" nsepseq(fun_type,"*") {
let value = Utils.nsepseq_cons $1 $2 $3 in let value = Utils.nsepseq_cons $1 $2 $3 in
let region = nsepseq_to_region type_expr_to_region value let region = nsepseq_to_region type_expr_to_region value
in TProd {region; value} in TProd {region; value} }
}
| fun_type { ($1 : type_expr) }
fun_type: fun_type:
core_type { core_type { $1 }
$1 | core_type "->" fun_type {
}
| core_type ARROW fun_type {
let start = type_expr_to_region $1 let start = type_expr_to_region $1
and stop = type_expr_to_region $3 in and stop = type_expr_to_region $3 in
let region = cover start stop in let region = cover start stop in
TFun {region; value=$1,$2,$3} } TFun {region; value=$1,$2,$3} }
core_type: core_type:
type_name { type_name { TVar $1 }
TVar $1 | par(type_expr) { TPar $1 }
} | module_name "." type_name {
| module_name DOT type_name {
let module_name = $1.value in let module_name = $1.value in
let type_name = $3.value in let type_name = $3.value in
let value = module_name ^ "." ^ type_name in let value = module_name ^ "." ^ type_name in
let region = cover $1.region $3.region let region = cover $1.region $3.region
in TVar {region; value} in TVar {region; value}
} }
| arg=core_type constr=type_constr { | core_type type_name {
let start = type_expr_to_region arg in let arg, constr = $1, $2 in
let stop = constr.region in let start = type_expr_to_region arg
and stop = constr.region in
let region = cover start stop in let region = cover start stop in
let lpar, rpar = ghost, ghost in let lpar, rpar = ghost, ghost in
let value = {lpar; inside=arg,[]; rpar} in let value = {lpar; inside=arg,[]; rpar} in
let arg = {value; region = start} in let arg = {region=start; value}
TApp Region.{value = (constr,arg); region} in TApp {region; value = constr,arg}
} }
| type_tuple type_constr { | type_tuple type_name {
let region = cover $1.region $2.region let arg, constr = $1, $2 in
in TApp {region; value = $2,$1} let region = cover arg.region constr.region
} in TApp {region; value = constr,arg} }
| par(type_expr) {
TPar $1 }
type_constr:
type_name { $1 }
type_tuple: type_tuple:
par(tuple(type_expr)) { $1 } par(tuple(type_expr)) { $1 }
sum_type: sum_type:
ioption(VBAR) nsepseq(variant,VBAR) { ioption("|") nsepseq(variant,"|") {
let region = nsepseq_to_region (fun x -> x.region) $2 let region = nsepseq_to_region (fun x -> x.region) $2
in {region; value=$2} } in TSum {region; value=$2} }
variant: variant:
Constr Of cartesian { "<constr>" { {$1 with value={constr=$1; arg=None}} }
| "<constr>" "of" cartesian {
let region = cover $1.region (type_expr_to_region $3) let region = cover $1.region (type_expr_to_region $3)
and value = {constr=$1; arg = Some ($2,$3)} and value = {constr=$1; arg = Some ($2,$3)}
in {region; value}
}
| Constr {
{region=$1.region; value={constr=$1; arg=None}} }
record_type:
LBRACE sep_or_term_list(field_decl,SEMI) RBRACE {
let ne_elements, terminator = $2 in
let region = cover $1 $3
and value = {
compound = Braces ($1,$3);
ne_elements;
terminator}
in {region; value} } in {region; value} }
record_type:
"{" sep_or_term_list(field_decl,";") "}" {
let ne_elements, terminator = $2 in
let region = cover $1 $3
and value = {compound = Braces ($1,$3); ne_elements; terminator}
in TRecord {region; value} }
field_decl: field_decl:
field_name COLON type_expr { field_name ":" type_expr {
let stop = type_expr_to_region $3 in let stop = type_expr_to_region $3 in
let region = cover $1.region stop let region = cover $1.region stop
and value = {field_name=$1; colon=$2; field_type=$3} and value = {field_name=$1; colon=$2; field_type=$3}
@ -249,164 +202,142 @@ field_decl:
(* Top-level non-recursive definitions *) (* Top-level non-recursive definitions *)
let_declaration: let_declaration:
Let let_binding { "let" let_binding {
let kwd_let = $1 in let kwd_let = $1 in
let binding = $2 in let binding = $2 in
let value = kwd_let, binding in let value = kwd_let, binding in
let stop = expr_to_region binding.let_rhs in let stop = expr_to_region binding.let_rhs in
let region = cover $1 stop let region = cover $1 stop
in {value; region} } in {region; value} }
let_binding: let_binding:
Ident nseq(sub_irrefutable) type_annotation? EQ expr { "<ident>" nseq(sub_irrefutable) type_annotation? "=" expr {
let binders = Utils.nseq_cons (PVar $1) $2 in let binders = Utils.nseq_cons (PVar $1) $2 in
{binders; lhs_type=$3; eq=$4; let_rhs=$5} {binders; lhs_type=$3; eq=$4; let_rhs=$5}
} }
| irrefutable type_annotation? EQ expr { | irrefutable type_annotation? "=" expr {
let binders = $1,[] in {binders=$1,[]; lhs_type=$2; eq=$3; let_rhs=$4} }
{binders; lhs_type=$2; eq=$3; let_rhs=$4} }
type_annotation: type_annotation:
COLON type_expr { $1,$2 } ":" type_expr { $1,$2 }
(* Patterns *) (* Patterns *)
irrefutable: irrefutable:
tuple(sub_irrefutable) { sub_irrefutable { $1 }
| tuple(sub_irrefutable) {
let hd, tl = $1 in let hd, tl = $1 in
let start = pattern_to_region hd in let start = pattern_to_region hd in
let stop = last fst tl in let stop = last fst tl in
let region = cover start stop let region = cover start stop
in PTuple {value=$1; region} in PTuple {region; value=$1} }
}
| sub_irrefutable { $1 }
sub_irrefutable: sub_irrefutable:
Ident { PVar $1 } "<ident>" { PVar $1 }
| WILD { PWild $1 } | "_" { PWild $1 }
| unit { PUnit $1 } | unit { PUnit $1 }
| record_pattern { PRecord $1 } | record_pattern { PRecord $1 }
| par(closed_irrefutable) { PPar $1 } | par(closed_irrefutable) { PPar $1 }
| Constr { | "<constr>" { PConstr (PConstrApp {$1 with value = $1,None}) }
let value = $1, None
and region = $1.region in PConstr (PConstrApp {value; region}) }
closed_irrefutable: closed_irrefutable:
irrefutable { irrefutable
$1 } | typed_pattern { $1 }
| Constr sub_pattern { | "<constr>" sub_pattern {
let stop = pattern_to_region $2 in let stop = pattern_to_region $2 in
let region = cover $1.region stop let region = cover $1.region stop
and value = $1, Some $2 and value = $1, Some $2 in
in PConstr (PConstrApp {value; region}) } PConstr (PConstrApp {region; value}) }
| typed_pattern {
PTyped $1 }
typed_pattern: typed_pattern:
irrefutable COLON type_expr { irrefutable ":" type_expr {
let start = pattern_to_region $1 in let start = pattern_to_region $1 in
let stop = type_expr_to_region $3 in let stop = type_expr_to_region $3 in
let region = cover start stop in let region = cover start stop in
let value = { let value = {pattern=$1; colon=$2; type_expr=$3}
pattern = $1; in PTyped {region; value} }
colon = $2;
type_expr = $3}
in {value; region} }
pattern: pattern:
sub_pattern CONS tail { core_pattern { $1 }
| sub_pattern "::" tail {
let start = pattern_to_region $1 in let start = pattern_to_region $1 in
let stop = pattern_to_region $3 in let stop = pattern_to_region $3 in
let region = cover start stop let region = cover start stop in
and value = $1, $2, $3 in PList (PCons {region; value=$1,$2,$3})
PList (PCons {region; value})
} }
| tuple(sub_pattern) { | tuple(sub_pattern) {
let start = pattern_to_region (fst $1) in let start = pattern_to_region (fst $1) in
let stop = last fst (snd $1) in let stop = last fst (snd $1) in
let region = cover start stop let region = cover start stop
in PTuple {value=$1; region} in PTuple {region; value=$1} }
}
| core_pattern { $1 }
sub_pattern: sub_pattern:
par(tail) { PPar $1 } par(tail) { PPar $1 }
| core_pattern { $1 } | core_pattern { $1 }
core_pattern: core_pattern:
Ident { PVar $1 } "<ident>" { PVar $1 }
| WILD { PWild $1 } | "_" { PWild $1 }
| Int { PInt $1 } | "<int>" { PInt $1 }
| Nat { PNat $1 } | "<nat>" { PNat $1 }
| Bytes { PBytes $1 } | "<bytes>" { PBytes $1 }
| String { PString $1 } | "<string>" { PString $1 }
| unit { PUnit $1 } | unit { PUnit $1 }
| False { PFalse $1 } | "false" { PFalse $1 }
| True { PTrue $1 } | "true" { PTrue $1 }
| par(ptuple) { PPar $1 } | par(ptuple) { PPar $1 }
| list(tail) { PList (PListComp $1) } | list(tail) { PList (PListComp $1) }
| constr_pattern { PConstr $1 } | constr_pattern { PConstr $1 }
| record_pattern { PRecord $1 } | record_pattern { PRecord $1 }
record_pattern: record_pattern:
LBRACE sep_or_term_list(field_pattern,SEMI) RBRACE { "{" sep_or_term_list(field_pattern,";") "}" {
let ne_elements, terminator = $2 in let ne_elements, terminator = $2 in
let region = cover $1 $3 in let region = cover $1 $3 in
let value = { let value = {compound = Braces ($1,$3); ne_elements; terminator}
compound = Braces ($1,$3);
ne_elements;
terminator}
in {region; value} } in {region; value} }
field_pattern: field_pattern:
field_name EQ sub_pattern { field_name "=" sub_pattern {
let start = $1.region let start = $1.region
and stop = pattern_to_region $3 in and stop = pattern_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {field_name=$1; eq=$2; pattern=$3} and value = {field_name=$1; eq=$2; pattern=$3}
in {value; region} } in {region; value} }
constr_pattern: constr_pattern:
C_None { PNone $1 } "None" { PNone $1 }
| C_Some sub_pattern { | "Some" sub_pattern {
let stop = pattern_to_region $2 in let stop = pattern_to_region $2 in
let region = cover $1 stop let region = cover $1 stop
and value = $1,$2 and value = $1,$2
in PSomeApp {value; region} in PSomeApp {region; value}
} }
| Constr sub_pattern? { | "<constr>" {
let start = $1.region in PConstrApp {$1 with value=$1,None}
let stop = }
match $2 with | "<constr>" sub_pattern {
Some p -> pattern_to_region p let region = cover $1.region (pattern_to_region $2)
| None -> start in in PConstrApp {region; value = $1, Some $2} }
let region = cover start stop
and value = $1,$2
in PConstrApp {value; region} }
ptuple: ptuple:
tuple(tail) { tuple(tail) {
let h, t = $1 in let hd, tl = $1 in
let start = pattern_to_region h in let start = pattern_to_region hd in
let stop = last fst t in let stop = last fst tl in
let region = cover start stop in let region = cover start stop
PTuple {value = $1; region} } in PTuple {region; value=$1} }
unit: unit:
LPAR RPAR { "(" ")" { {region = cover $1 $2; value = ghost, ghost} }
let value = ghost, ghost in
let region = cover $1 $2
in {value; region} }
tail: tail:
sub_pattern CONS tail { sub_pattern { $1 }
| sub_pattern "::" tail {
let start = pattern_to_region $1 in let start = pattern_to_region $1 in
let stop = pattern_to_region $3 in let stop = pattern_to_region $3 in
let region = cover start stop in let region = cover start stop in
PList (PCons {value = ($1, $2, $3); region} ) PList (PCons {region; value=$1,$2,$3}) }
}
| sub_pattern {
$1 }
(* Expressions *) (* Expressions *)
@ -414,72 +345,67 @@ interactive_expr:
expr EOF { $1 } expr EOF { $1 }
expr: expr:
base_cond__open(expr) { $1 } base_cond__open(expr) | match_expr(base_cond) { $1 }
| match_expr(base_cond) { ECase $1 }
base_cond__open(x): base_cond__open(x):
base_expr(x) base_expr(x) | conditional(x) { $1 }
| conditional(x) { $1 }
base_cond: base_cond:
base_cond__open(base_cond) { $1 } base_cond__open(base_cond) { $1 }
base_expr(right_expr): base_expr(right_expr):
tuple_expr
| let_expr(right_expr)
| fun_expr(right_expr)
| disj_expr_level { $1 }
tuple_expr:
tuple(disj_expr_level) { tuple(disj_expr_level) {
let start = expr_to_region (fst $1) in let start = expr_to_region (fst $1) in
let stop = last fst (snd $1) in let stop = last fst (snd $1) in
let region = cover start stop let region = cover start stop
in ETuple {value=$1; region} in ETuple {region; value=$1} }
}
| let_expr(right_expr)
| fun_expr(right_expr)
| disj_expr_level {
$1 }
conditional(right_expr): conditional(right_expr):
if_then_else(right_expr) if_then_else(right_expr) | if_then(right_expr) { $1 }
| if_then(right_expr) { ECond $1 }
if_then(right_expr):
If expr Then right_expr {
let the_unit = ghost, ghost in
let ifnot = EUnit {region=ghost; value=the_unit} in
let stop = expr_to_region $4 in
let region = cover $1 stop in
let value = {
kwd_if = $1;
test = $2;
kwd_then = $3;
ifso = $4;
kwd_else = ghost;
ifnot}
in {value; region} }
if_then_else(right_expr): if_then_else(right_expr):
If expr Then closed_if Else right_expr { "if" expr "then" closed_if "else" right_expr {
let region = cover $1 (expr_to_region $6) let region = cover $1 (expr_to_region $6)
and value = { and value = {kwd_if = $1;
kwd_if = $1;
test = $2; test = $2;
kwd_then = $3; kwd_then = $3;
ifso = $4; ifso = $4;
kwd_else = $5; kwd_else = $5;
ifnot = $6} ifnot = $6}
in {value; region} } in ECond {region; value} }
if_then(right_expr):
"if" expr "then" right_expr {
let the_unit = ghost, ghost in
let ifnot = EUnit (wrap_ghost the_unit) in
let stop = expr_to_region $4 in
let region = cover $1 stop in
let value = {kwd_if = $1;
test = $2;
kwd_then = $3;
ifso = $4;
kwd_else = ghost;
ifnot}
in ECond {region; value} }
base_if_then_else__open(x): base_if_then_else__open(x):
base_expr(x) { $1 } base_expr(x) | if_then_else(x) { $1 }
| if_then_else(x) { ECond $1 }
base_if_then_else: base_if_then_else:
base_if_then_else__open(base_if_then_else) { $1 } base_if_then_else__open(base_if_then_else) { $1 }
closed_if: closed_if:
base_if_then_else__open(closed_if) { $1 } base_if_then_else__open(closed_if)
| match_expr(base_if_then_else) { ECase $1 } | match_expr(base_if_then_else) { $1 }
match_expr(right_expr): match_expr(right_expr):
Match expr With VBAR? cases(right_expr) { "match" expr "with" "|"? cases(right_expr) {
let cases = { let cases = {
value = Utils.nsepseq_rev $5; value = Utils.nsepseq_rev $5;
region = nsepseq_to_region (fun x -> x.region) $5} region = nsepseq_to_region (fun x -> x.region) $5}
@ -488,192 +414,144 @@ match_expr(right_expr):
{region; _}, [] -> region {region; _}, [] -> region
| _, tl -> last fst tl in | _, tl -> last fst tl in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {kwd_match = $1;
kwd_match = $1;
expr = $2; expr = $2;
kwd_with = $3; kwd_with = $3;
lead_vbar = $4; lead_vbar = $4;
cases} cases}
in {value; region} } in ECase {region; value} }
cases(right_expr): cases(right_expr):
case_clause(right_expr) { case_clause(right_expr) {
let start = pattern_to_region $1.pattern let start = pattern_to_region $1.pattern
and stop = expr_to_region $1.rhs in and stop = expr_to_region $1.rhs in
let region = cover start stop let region = cover start stop
in {value=$1; region}, [] in {region; value=$1}, []
} }
| cases(base_cond) VBAR case_clause(right_expr) { | cases(base_cond) "|" case_clause(right_expr) {
let start = let start =
match $1 with match $1 with
only_case, [] -> only_case.region only_case, [] -> only_case.region
| _, other_cases -> last fst other_cases | _, other_cases -> last fst other_cases
and stop = expr_to_region $3.rhs in and stop = expr_to_region $3.rhs in
let region = cover start stop in let region = cover start stop in
let fst_case = {value=$3; region} let fst_case = {region; value=$3}
and snd_case, others = $1 and snd_case, others = $1
in fst_case, ($2,snd_case)::others } in fst_case, ($2,snd_case)::others }
case_clause(right_expr): case_clause(right_expr):
pattern ARROW right_expr { pattern "->" right_expr { {pattern=$1; arrow=$2; rhs=$3} }
{pattern=$1; arrow=$2; rhs=$3} }
let_expr(right_expr): let_expr(right_expr):
Let let_binding In right_expr { "let" let_binding "in" right_expr {
let kwd_let = $1 in let kwd_let = $1
let binding = $2 in and binding = $2
let kwd_in = $3 in and kwd_in = $3
let body = $4 in and body = $4 in
let stop = expr_to_region $4 in let stop = expr_to_region body in
let region = cover $1 stop in let region = cover kwd_let stop
let let_in = {kwd_let; binding; kwd_in; body} and value = {kwd_let; binding; kwd_in; body}
in ELetIn {region; value=let_in} } in ELetIn {region; value} }
fun_expr(right_expr): fun_expr(right_expr):
Fun nseq(irrefutable) ARROW right_expr { "fun" nseq(irrefutable) "->" right_expr {
let stop = expr_to_region $4 in let stop = expr_to_region $4 in
let region = cover $1 stop in let region = cover $1 stop in
let f = { let value = {kwd_fun = $1;
kwd_fun = $1;
binders = $2; binders = $2;
lhs_type = None; lhs_type = None;
arrow = $3; arrow = $3;
body = $4} body = $4}
in EFun {region; value=f} } in EFun {region; value} }
disj_expr_level: disj_expr_level:
disj_expr { ELogic (BoolExpr (Or $1)) } bin_op(disj_expr_level, "||", conj_expr_level)
| bin_op(disj_expr_level, "or", conj_expr_level) {
ELogic (BoolExpr (Or $1)) }
| conj_expr_level { $1 } | conj_expr_level { $1 }
bin_op(arg1,op,arg2): bin_op(arg1,op,arg2):
arg1 op arg2 { arg1 op arg2 {
let start = expr_to_region $1 in let start = expr_to_region $1 in
let stop = expr_to_region $3 in let stop = expr_to_region $3 in
let region = cover start stop in let region = cover start stop
{value={arg1=$1; op=$2; arg2=$3}; region} and value = {arg1=$1; op=$2; arg2=$3}
} in {region; value} }
disj_expr:
bin_op(disj_expr_level, BOOL_OR, conj_expr_level)
| bin_op(disj_expr_level, Or, conj_expr_level) { $1 }
conj_expr_level: conj_expr_level:
conj_expr { ELogic (BoolExpr (And $1)) } bin_op(conj_expr_level, "&&", comp_expr_level) {
ELogic (BoolExpr (And $1)) }
| comp_expr_level { $1 } | comp_expr_level { $1 }
conj_expr:
bin_op(conj_expr_level, BOOL_AND, comp_expr_level) { $1 }
comp_expr_level: comp_expr_level:
lt_expr { ELogic (CompExpr (Lt $1)) } bin_op(comp_expr_level, "<", cat_expr_level) {
| le_expr { ELogic (CompExpr (Leq $1)) } ELogic (CompExpr (Lt $1)) }
| gt_expr { ELogic (CompExpr (Gt $1)) } | bin_op(comp_expr_level, "<=", cat_expr_level) {
| ge_expr { ELogic (CompExpr (Geq $1)) } ELogic (CompExpr (Leq $1)) }
| eq_expr { ELogic (CompExpr (Equal $1)) } | bin_op(comp_expr_level, ">", cat_expr_level) {
| ne_expr { ELogic (CompExpr (Neq $1)) } ELogic (CompExpr (Gt $1)) }
| bin_op(comp_expr_level, ">=", cat_expr_level) {
ELogic (CompExpr (Geq $1)) }
| bin_op(comp_expr_level, "=", cat_expr_level) {
ELogic (CompExpr (Equal $1)) }
| bin_op(comp_expr_level, "<>", cat_expr_level) {
ELogic (CompExpr (Neq $1)) }
| cat_expr_level { $1 } | cat_expr_level { $1 }
lt_expr:
bin_op(comp_expr_level, LT, cat_expr_level) { $1 }
le_expr:
bin_op(comp_expr_level, LE, cat_expr_level) { $1 }
gt_expr:
bin_op(comp_expr_level, GT, cat_expr_level) { $1 }
ge_expr:
bin_op(comp_expr_level, GE, cat_expr_level) { $1 }
eq_expr:
bin_op(comp_expr_level, EQ, cat_expr_level) { $1 }
ne_expr:
bin_op(comp_expr_level, NE, cat_expr_level) { $1 }
cat_expr_level: cat_expr_level:
cat_expr { EString (Cat $1) } bin_op(cons_expr_level, "^", cat_expr_level) { EString (Cat $1) }
(*| reg(append_expr) { EList (Append $1) } *) (*| reg(append_expr) {
bin_op(cons_expr_level, "@", cat_expr_level) { EList (Append $1) } *)
| cons_expr_level { $1 } | cons_expr_level { $1 }
cat_expr:
bin_op(cons_expr_level, CAT, cat_expr_level) { $1 }
(*
append_expr:
cons_expr_level sym(APPEND) cat_expr_level { $1,$2,$3 }
*)
cons_expr_level: cons_expr_level:
cons_expr { EList (ECons $1) } bin_op(add_expr_level, "::", cons_expr_level) { EList (ECons $1) }
| add_expr_level { $1 } | add_expr_level { $1 }
cons_expr:
bin_op(add_expr_level, CONS, cons_expr_level) { $1 }
add_expr_level: add_expr_level:
plus_expr { EArith (Add $1) } bin_op(add_expr_level, "+", mult_expr_level) { EArith (Add $1) }
| minus_expr { EArith (Sub $1) } | bin_op(add_expr_level, "-", mult_expr_level) { EArith (Sub $1) }
| mult_expr_level { $1 } | mult_expr_level { $1 }
plus_expr:
bin_op(add_expr_level, PLUS, mult_expr_level) { $1 }
minus_expr:
bin_op(add_expr_level, MINUS, mult_expr_level) { $1 }
mult_expr_level: mult_expr_level:
times_expr { EArith (Mult $1) } bin_op(mult_expr_level, "*", unary_expr_level) { EArith (Mult $1) }
| div_expr { EArith (Div $1) } | bin_op(mult_expr_level, "/", unary_expr_level) { EArith (Div $1) }
| mod_expr { EArith (Mod $1) } | bin_op(mult_expr_level, "mod", unary_expr_level) { EArith (Mod $1) }
| unary_expr_level { $1 } | unary_expr_level { $1 }
times_expr:
bin_op(mult_expr_level, TIMES, unary_expr_level) { $1 }
div_expr:
bin_op(mult_expr_level, SLASH, unary_expr_level) { $1 }
mod_expr:
bin_op(mult_expr_level, Mod, unary_expr_level) { $1 }
unary_expr_level: unary_expr_level:
MINUS call_expr_level { call_expr_level { $1 }
| "-" call_expr_level {
let start = $1 in let start = $1 in
let stop = expr_to_region $2 in let stop = expr_to_region $2 in
let region = cover start stop let region = cover start stop
and value = {op=$1; arg=$2} and value = {op=$1; arg=$2}
in EArith (Neg {region; value}) } in EArith (Neg {region; value})
| Not call_expr_level { }
| "not" call_expr_level {
let start = $1 in let start = $1 in
let stop = expr_to_region $2 in let stop = expr_to_region $2 in
let region = cover start stop let region = cover start stop
and value = {op=$1; arg=$2} in and value = {op=$1; arg=$2} in
ELogic (BoolExpr (Not ({region; value}))) } ELogic (BoolExpr (Not ({region; value}))) }
| call_expr_level {
$1 }
call_expr_level: call_expr_level:
call_expr { ECall $1 } call_expr | constr_expr | core_expr { $1 }
| constr_expr { EConstr $1 }
| core_expr { $1 }
constr_expr: constr_expr:
C_None { "None" {
ENone $1 EConstr (ENone $1)
} }
| C_Some core_expr { | "Some" core_expr {
let region = cover $1 (expr_to_region $2) let region = cover $1 (expr_to_region $2)
in ESomeApp {value = $1,$2; region} in EConstr (ESomeApp {region; value=$1,$2})
} }
| Constr core_expr? { | "<constr>" core_expr {
let start = $1.region in let region = cover $1.region (expr_to_region $2) in
let stop = EConstr (EConstrApp {region; value=$1, Some $2})
match $2 with }
Some c -> expr_to_region c | "<constr>" {
| None -> start in EConstr (EConstrApp {$1 with value=$1, None}) }
let region = cover start stop
in EConstrApp {value=$1,$2; region} }
call_expr: call_expr:
core_expr nseq(core_expr) { core_expr nseq(core_expr) {
@ -682,92 +560,77 @@ call_expr:
e, [] -> expr_to_region e e, [] -> expr_to_region e
| _, l -> last expr_to_region l in | _, l -> last expr_to_region l in
let region = cover start stop in let region = cover start stop in
{value = $1,$2; region} } ECall {region; value=$1,$2} }
core_expr: core_expr:
Int { EArith (Int $1) } "<int>" { EArith (Int $1) }
| Mutez { EArith (Mutez $1) } | "<mutez>" { EArith (Mutez $1) }
| Nat { EArith (Nat $1) } | "<nat>" { EArith (Nat $1) }
| Ident | module_field { EVar $1 } | "<ident>" | module_field { EVar $1 }
| projection { EProj $1 } | projection { EProj $1 }
| String { EString (String $1) } | "<string>" { EString (String $1) }
| unit { EUnit $1 } | unit { EUnit $1 }
| False { ELogic (BoolExpr (False $1)) } | "false" { ELogic (BoolExpr (False $1)) }
| True { ELogic (BoolExpr (True $1)) } | "true" { ELogic (BoolExpr (True $1)) }
| list(expr) { EList (EListComp $1) } | list(expr) { EList (EListComp $1) }
| par(expr) { EPar $1 }
| sequence { ESeq $1 } | sequence { ESeq $1 }
| record_expr { ERecord $1 } | record_expr { ERecord $1 }
| par(expr COLON type_expr {$1,$3}) { | par(expr) { EPar $1 }
EAnnot {$1 with value=$1.value.inside} } | par(expr ":" type_expr {$1,$2,$3}) { EAnnot $1 }
module_field: module_field:
module_name DOT field_name { module_name "." field_name {
let region = cover $1.region $3.region in let region = cover $1.region $3.region in
{value = $1.value ^ "." ^ $3.value; region} } {region; value = $1.value ^ "." ^ $3.value} }
projection: projection:
struct_name DOT nsepseq(selection,DOT) { struct_name "." nsepseq(selection,".") {
let start = $1.region in let start = $1.region in
let stop = nsepseq_to_region selection_to_region $3 in let stop = nsepseq_to_region selection_to_region $3 in
let region = cover start stop in let region = cover start stop in
let value = { let value = {struct_name=$1; selector=$2; field_path=$3}
struct_name = $1; in {region; value}
selector = $2;
field_path = $3}
in {value; region}
} }
| module_name DOT field_name DOT nsepseq(selection,DOT) { | module_name "." field_name "." nsepseq(selection,".") {
let value = $1.value ^ "." ^ $3.value in let value = $1.value ^ "." ^ $3.value in
let struct_name = {$1 with value} in let struct_name = {$1 with value} in
let start = $1.region in let start = $1.region in
let stop = nsepseq_to_region selection_to_region $5 in let stop = nsepseq_to_region selection_to_region $5 in
let region = cover start stop in let region = cover start stop in
let value = { let value = {struct_name; selector=$4; field_path=$5}
struct_name; in {region; value} }
selector = $4;
field_path = $5}
in {value; region} }
selection: selection:
field_name { FieldName $1 } field_name { FieldName $1 }
| Int { Component $1 } | "<int>" { Component $1 }
record_expr: record_expr:
LBRACE sep_or_term_list(field_assignment,SEMI) RBRACE { "{" sep_or_term_list(field_assignment,";") "}" {
let ne_elements, terminator = $2 in let ne_elements, terminator = $2 in
let region = cover $1 $3 in let region = cover $1 $3 in
let value = { let value = {compound = Braces ($1,$3);
compound = Braces ($1,$3);
ne_elements; ne_elements;
terminator} terminator}
in {value; region} } in {region; value} }
field_assignment: field_assignment:
field_name EQ expr { field_name "=" expr {
let start = $1.region in let start = $1.region in
let stop = expr_to_region $3 in let stop = expr_to_region $3 in
let region = cover start stop in let region = cover start stop in
let value = { let value = {field_name = $1;
field_name = $1;
assignment = $2; assignment = $2;
field_expr = $3} field_expr = $3}
in {value; region} } in {region; value} }
sequence: sequence:
Begin sep_or_term_list(expr,SEMI) End { "begin" sep_or_term_list(expr,";")? "end" {
let ne_elements, terminator = $2 in
let value = {
compound = BeginEnd ($1,$3);
elements = Some ne_elements;
terminator} in
let region = cover $1 $3 let region = cover $1 $3
in {value; region} and compound = BeginEnd ($1,$3) in
} let elements, terminator =
| Begin End { match $2 with
let value = { None -> None, None
compound = BeginEnd ($1,$2); | Some (ne_elements, terminator) ->
elements = None; Some ne_elements, terminator in
terminator = None} in let value = {compound; elements; terminator}
let region = cover $1 $2 in {region; value} }
in {value; region} }

12
src/passes/1-parser/cameligo/ParserLog.ml
View File

@ -369,10 +369,13 @@ and print_fun_call state {value=f,l; _} =
print_expr state f; print_expr state f;
Utils.nseq_iter (print_expr state) l Utils.nseq_iter (print_expr state) l
and print_annot_expr state {value=e,t; _} = and print_annot_expr state {value; _} =
let {lpar; inside=e,colon,t; rpar} = value in
print_token state lpar "(";
print_expr state e; print_expr state e;
print_token state Region.ghost ":"; print_token state colon ":";
print_type_expr state t print_type_expr state t;
print_token state rpar ")"
and print_list_expr state = function and print_list_expr state = function
ECons {value={arg1;op;arg2}; _} -> ECons {value={arg1;op;arg2}; _} ->
@ -967,7 +970,8 @@ and pp_bin_op node region state op =
pp_expr (state#pad 2 0) op.arg1; pp_expr (state#pad 2 0) op.arg1;
pp_expr (state#pad 2 1) op.arg2 pp_expr (state#pad 2 1) op.arg2
and pp_annotated state (expr, t_expr) = and pp_annotated state annot =
let expr, _, t_expr = annot.inside in
pp_expr (state#pad 2 0) expr; pp_expr (state#pad 2 0) expr;
pp_type_expr (state#pad 2 1) t_expr pp_type_expr (state#pad 2 1) t_expr

142
src/passes/1-parser/pascaligo/ParToken.mly
View File

@ -5,86 +5,86 @@
(* Literals *) (* Literals *)
%token <LexToken.lexeme Region.reg> String %token <LexToken.lexeme Region.reg> String "<string>"
%token <(LexToken.lexeme * Hex.t) Region.reg> Bytes %token <(LexToken.lexeme * Hex.t) Region.reg> Bytes "<bytes>"
%token <(LexToken.lexeme * Z.t) Region.reg> Int %token <(LexToken.lexeme * Z.t) Region.reg> Int "<int>"
%token <(LexToken.lexeme * Z.t) Region.reg> Nat %token <(LexToken.lexeme * Z.t) Region.reg> Nat "<nat>"
%token <(LexToken.lexeme * Z.t) Region.reg> Mutez %token <(LexToken.lexeme * Z.t) Region.reg> Mutez "<mutez>"
%token <LexToken.lexeme Region.reg> Ident %token <LexToken.lexeme Region.reg> Ident "<ident>"
%token <LexToken.lexeme Region.reg> Constr %token <LexToken.lexeme Region.reg> Constr "<constr>"
(* Symbols *) (* Symbols *)
%token <Region.t> SEMI (* ";" *) %token <Region.t> SEMI ";"
%token <Region.t> COMMA (* "," *) %token <Region.t> COMMA ","
%token <Region.t> LPAR (* "(" *) %token <Region.t> LPAR "("
%token <Region.t> RPAR (* ")" *) %token <Region.t> RPAR ")"
%token <Region.t> LBRACE (* "{" *) %token <Region.t> LBRACE "{"
%token <Region.t> RBRACE (* "}" *) %token <Region.t> RBRACE "}"
%token <Region.t> LBRACKET (* "[" *) %token <Region.t> LBRACKET "["
%token <Region.t> RBRACKET (* "]" *) %token <Region.t> RBRACKET "]"
%token <Region.t> CONS (* "#" *) %token <Region.t> CONS "#"
%token <Region.t> VBAR (* "|" *) %token <Region.t> VBAR "|"
%token <Region.t> ARROW (* "->" *) %token <Region.t> ARROW "->"
%token <Region.t> ASS (* ":=" *) %token <Region.t> ASS ":="
%token <Region.t> EQ (* "=" *) %token <Region.t> EQ "="
%token <Region.t> COLON (* ":" *) %token <Region.t> COLON ":"
%token <Region.t> LT (* "<" *) %token <Region.t> LT "<"
%token <Region.t> LE (* "<=" *) %token <Region.t> LE "<="
%token <Region.t> GT (* ">" *) %token <Region.t> GT ">"
%token <Region.t> GE (* ">=" *) %token <Region.t> GE ">="
%token <Region.t> NE (* "=/=" *) %token <Region.t> NE "=/="
%token <Region.t> PLUS (* "+" *) %token <Region.t> PLUS "+"
%token <Region.t> MINUS (* "-" *) %token <Region.t> MINUS "-"
%token <Region.t> SLASH (* "/" *) %token <Region.t> SLASH "/"
%token <Region.t> TIMES (* "*" *) %token <Region.t> TIMES "*"
%token <Region.t> DOT (* "." *) %token <Region.t> DOT "."
%token <Region.t> WILD (* "_" *) %token <Region.t> WILD "_"
%token <Region.t> CAT (* "^" *) %token <Region.t> CAT "^"
(* Keywords *) (* Keywords *)
%token <Region.t> And (* "and" *) %token <Region.t> And "and"
%token <Region.t> Begin (* "begin" *) %token <Region.t> Begin "begin"
%token <Region.t> BigMap (* "big_map" *) %token <Region.t> BigMap "big_map"
%token <Region.t> Block (* "block" *) %token <Region.t> Block "block"
%token <Region.t> Case (* "case" *) %token <Region.t> Case "case"
%token <Region.t> Const (* "const" *) %token <Region.t> Const "const"
%token <Region.t> Contains (* "contains" *) %token <Region.t> Contains "contains"
%token <Region.t> Else (* "else" *) %token <Region.t> Else "else"
%token <Region.t> End (* "end" *) %token <Region.t> End "end"
%token <Region.t> False (* "False" *) %token <Region.t> False "False"
%token <Region.t> For (* "for" *) %token <Region.t> For "for"
%token <Region.t> Function (* "function" *) %token <Region.t> Function "function"
%token <Region.t> From (* "from" *) %token <Region.t> From "from"
%token <Region.t> If (* "if" *) %token <Region.t> If "if"
%token <Region.t> In (* "in" *) %token <Region.t> In "in"
%token <Region.t> Is (* "is" *) %token <Region.t> Is "is"
%token <Region.t> List (* "list" *) %token <Region.t> List "list"
%token <Region.t> Map (* "map" *) %token <Region.t> Map "map"
%token <Region.t> Mod (* "mod" *) %token <Region.t> Mod "mod"
%token <Region.t> Nil (* "nil" *) %token <Region.t> Nil "nil"
%token <Region.t> Not (* "not" *) %token <Region.t> Not "not"
%token <Region.t> Of (* "of" *) %token <Region.t> Of "of"
%token <Region.t> Or (* "or" *) %token <Region.t> Or "or"
%token <Region.t> Patch (* "patch" *) %token <Region.t> Patch "patch"
%token <Region.t> Record (* "record" *) %token <Region.t> Record "record"
%token <Region.t> Remove (* "remove" *) %token <Region.t> Remove "remove"
%token <Region.t> Set (* "set" *) %token <Region.t> Set "set"
%token <Region.t> Skip (* "skip" *) %token <Region.t> Skip "skip"
%token <Region.t> Then (* "then" *) %token <Region.t> Then "then"
%token <Region.t> To (* "to" *) %token <Region.t> To "to"
%token <Region.t> True (* "True" *) %token <Region.t> True "True"
%token <Region.t> Type (* "type" *) %token <Region.t> Type "type"
%token <Region.t> Unit (* "Unit" *) %token <Region.t> Unit "Unit"
%token <Region.t> Var (* "var" *) %token <Region.t> Var "var"
%token <Region.t> While (* "while" *) %token <Region.t> While "while"
%token <Region.t> With (* "with" *) %token <Region.t> With "with"
(* Data constructors *) (* Data constructors *)
%token <Region.t> C_None (* "None" *) %token <Region.t> C_None "None"
%token <Region.t> C_Some (* "Some" *) %token <Region.t> C_Some "Some"
(* Virtual tokens *) (* Virtual tokens *)

295
src/passes/1-parser/pascaligo/Parser.mly
View File

@ -41,24 +41,22 @@ sep_or_term_list(item,sep):
(* Compound constructs *) (* Compound constructs *)
par(X): par(X):
LPAR X RPAR { "(" X ")" {
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
lpar = $1; lpar = $1;
inside = $2; inside = $2;
rpar = $3} rpar = $3}
in {region; value} in {region; value} }
}
brackets(X): brackets(X):
LBRACKET X RBRACKET { "[" X "]" {
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
lbracket = $1; lbracket = $1;
inside = $2; inside = $2;
rbracket = $3} rbracket = $3}
in {region; value} in {region; value} }
}
(* Sequences (* Sequences
@ -100,18 +98,17 @@ sepseq(X,Sep):
(* Inlines *) (* Inlines *)
%inline var : Ident { $1 } %inline var : "<ident>" { $1 }
%inline type_name : Ident { $1 } %inline type_name : "<ident>" { $1 }
%inline fun_name : Ident { $1 } %inline fun_name : "<ident>" { $1 }
%inline field_name : Ident { $1 } %inline field_name : "<ident>" { $1 }
%inline struct_name : Ident { $1 } %inline struct_name : "<ident>" { $1 }
(* Main *) (* Main *)
contract: contract:
nseq(declaration) EOF { nseq(declaration) EOF {
{decl = $1; eof = $2} {decl = $1; eof = $2} }
}
declaration: declaration:
type_decl { TypeDecl $1 } type_decl { TypeDecl $1 }
@ -121,7 +118,7 @@ declaration:
(* Type declarations *) (* Type declarations *)
type_decl: type_decl:
Type type_name Is type_expr option(SEMI) { "type" type_name "is" type_expr ";"? {
let stop = let stop =
match $5 with match $5 with
Some region -> region Some region -> region
@ -133,8 +130,7 @@ type_decl:
kwd_is = $3; kwd_is = $3;
type_expr = $4; type_expr = $4;
terminator = $5} terminator = $5}
in {region; value} in {region; value} }
}
type_expr: type_expr:
sum_type { TSum $1 } sum_type { TSum $1 }
@ -142,7 +138,7 @@ type_expr:
| cartesian { $1 } | cartesian { $1 }
cartesian: cartesian:
function_type TIMES nsepseq(function_type,TIMES) { function_type "*" nsepseq(function_type,"*") {
let value = Utils.nsepseq_cons $1 $2 $3 in let value = Utils.nsepseq_cons $1 $2 $3 in
let region = nsepseq_to_region type_expr_to_region value let region = nsepseq_to_region type_expr_to_region value
in TProd {region; value} in TProd {region; value}
@ -153,7 +149,7 @@ function_type:
core_type { core_type {
$1 $1
} }
| core_type ARROW function_type { | core_type "->" function_type {
let start = type_expr_to_region $1 let start = type_expr_to_region $1
and stop = type_expr_to_region $3 in and stop = type_expr_to_region $3 in
let region = cover start stop in let region = cover start stop in
@ -167,24 +163,24 @@ core_type:
let region = cover $1.region $2.region let region = cover $1.region $2.region
in TApp {region; value = $1,$2} in TApp {region; value = $1,$2}
} }
| Map type_tuple { | "map" type_tuple {
let region = cover $1 $2.region in let region = cover $1 $2.region in
let type_constr = {value="map"; region=$1} let type_constr = {value="map"; region=$1}
in TApp {region; value = type_constr, $2} in TApp {region; value = type_constr, $2}
} }
| BigMap type_tuple { | "big_map" type_tuple {
let region = cover $1 $2.region in let region = cover $1 $2.region in
let type_constr = {value="big_map"; region=$1} let type_constr = {value="big_map"; region=$1}
in TApp {region; value = type_constr, $2} in TApp {region; value = type_constr, $2}
} }
| Set par(type_expr) { | "set" par(type_expr) {
let total = cover $1 $2.region in let total = cover $1 $2.region in
let type_constr = {value="set"; region=$1} in let type_constr = {value="set"; region=$1} in
let {region; value = {lpar; inside; rpar}} = $2 in let {region; value = {lpar; inside; rpar}} = $2 in
let tuple = {region; value={lpar; inside=inside,[]; rpar}} let tuple = {region; value={lpar; inside=inside,[]; rpar}}
in TApp {region=total; value = type_constr, tuple} in TApp {region=total; value = type_constr, tuple}
} }
| List par(type_expr) { | "list" par(type_expr) {
let total = cover $1 $2.region in let total = cover $1 $2.region in
let type_constr = {value="list"; region=$1} in let type_constr = {value="list"; region=$1} in
let {region; value = {lpar; inside; rpar}} = $2 in let {region; value = {lpar; inside; rpar}} = $2 in
@ -195,24 +191,24 @@ core_type:
TPar $1} TPar $1}
type_tuple: type_tuple:
par(nsepseq(type_expr,COMMA)) { $1 } par(nsepseq(type_expr,",")) { $1 }
sum_type: sum_type:
option(VBAR) nsepseq(variant,VBAR) { "|"? nsepseq(variant,"|") {
let region = nsepseq_to_region (fun x -> x.region) $2 let region = nsepseq_to_region (fun x -> x.region) $2
in {region; value=$2} } in {region; value=$2} }
variant: variant:
Constr Of cartesian { "<constr>" "of" cartesian {
let region = cover $1.region (type_expr_to_region $3) let region = cover $1.region (type_expr_to_region $3)
and value = {constr = $1; arg = Some ($2, $3)} and value = {constr = $1; arg = Some ($2, $3)}
in {region; value} in {region; value}
} }
| Constr { | "<constr>" {
{region=$1.region; value= {constr=$1; arg=None}} } {region=$1.region; value= {constr=$1; arg=None}} }
record_type: record_type:
Record sep_or_term_list(field_decl,SEMI) End { "record" sep_or_term_list(field_decl,";") "end" {
let ne_elements, terminator = $2 in let ne_elements, terminator = $2 in
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
@ -222,7 +218,7 @@ record_type:
closing = End $3} closing = End $3}
in {region; value} in {region; value}
} }
| Record LBRACKET sep_or_term_list(field_decl,SEMI) RBRACKET { | "record" "[" sep_or_term_list(field_decl,";") "]" {
let ne_elements, terminator = $3 in let ne_elements, terminator = $3 in
let region = cover $1 $4 let region = cover $1 $4
and value = { and value = {
@ -233,16 +229,16 @@ record_type:
in {region; value} } in {region; value} }
field_decl: field_decl:
field_name COLON type_expr { field_name ":" type_expr {
let stop = type_expr_to_region $3 in let stop = type_expr_to_region $3 in
let region = cover $1.region stop let region = cover $1.region stop
and value = {field_name = $1; colon = $2; field_type = $3} and value = {field_name = $1; colon = $2; field_type = $3}
in {region; value} } in {region; value} }
fun_expr: fun_expr:
Function option(fun_name) parameters COLON type_expr Is "function" fun_name? parameters ":" type_expr "is"
block block
With expr { "with" expr {
let stop = expr_to_region $9 in let stop = expr_to_region $9 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -255,8 +251,7 @@ fun_expr:
block_with = Some ($7, $8); block_with = Some ($7, $8);
return = $9} return = $9}
in {region;value} } in {region;value} }
| Function option(fun_name) parameters COLON type_expr Is | "function" fun_name? parameters ":" type_expr "is" expr {
expr {
let stop = expr_to_region $7 in let stop = expr_to_region $7 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -271,11 +266,10 @@ fun_expr:
in {region;value} } in {region;value} }
(* Function declarations *) (* Function declarations *)
fun_decl: fun_decl:
fun_expr option(SEMI) { fun_expr ";"? {
let stop = let stop =
match $2 with match $2 with
Some region -> region Some region -> region
@ -295,10 +289,10 @@ open_fun_decl:
in {region; value} } in {region; value} }
parameters: parameters:
par(nsepseq(param_decl,SEMI)) { $1 } par(nsepseq(param_decl,";")) { $1 }
param_decl: param_decl:
Var var COLON param_type { "var" var ":" param_type {
let stop = type_expr_to_region $4 in let stop = type_expr_to_region $4 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -308,7 +302,7 @@ param_decl:
param_type = $4} param_type = $4}
in ParamVar {region; value} in ParamVar {region; value}
} }
| Const var COLON param_type { | "const" var ":" param_type {
let stop = type_expr_to_region $4 in let stop = type_expr_to_region $4 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -322,7 +316,7 @@ param_type:
cartesian { $1 } cartesian { $1 }
block: block:
Begin sep_or_term_list(statement,SEMI) End { "begin" sep_or_term_list(statement,";") "end" {
let statements, terminator = $2 in let statements, terminator = $2 in
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
@ -332,7 +326,7 @@ block:
closing = End $3} closing = End $3}
in {region; value} in {region; value}
} }
| Block LBRACE sep_or_term_list(statement,SEMI) RBRACE { | "block" "{" sep_or_term_list(statement,";") "}" {
let statements, terminator = $3 in let statements, terminator = $3 in
let region = cover $1 $4 let region = cover $1 $4
and value = { and value = {
@ -352,7 +346,7 @@ open_data_decl:
| open_fun_decl { LocalFun $1 } | open_fun_decl { LocalFun $1 }
open_const_decl: open_const_decl:
Const unqualified_decl(EQ) { "const" unqualified_decl("=") {
let name, colon, const_type, equal, init, stop = $2 in let name, colon, const_type, equal, init, stop = $2 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -366,7 +360,7 @@ open_const_decl:
in {region; value} } in {region; value} }
open_var_decl: open_var_decl:
Var unqualified_decl(ASS) { "var" unqualified_decl(":=") {
let name, colon, var_type, assign, init, stop = $2 in let name, colon, var_type, assign, init, stop = $2 in
let region = cover $1 stop let region = cover $1 stop
and value = { and value = {
@ -380,12 +374,12 @@ open_var_decl:
in {region; value} } in {region; value} }
unqualified_decl(OP): unqualified_decl(OP):
var COLON type_expr OP expr { var ":" type_expr OP expr {
let region = expr_to_region $5 let region = expr_to_region $5
in $1, $2, $3, $4, $5, region } in $1, $2, $3, $4, $5, region }
const_decl: const_decl:
open_const_decl SEMI { open_const_decl ";" {
let const_decl : AST.const_decl = $1.value in let const_decl : AST.const_decl = $1.value in
{$1 with value = {const_decl with terminator = Some $2}} {$1 with value = {const_decl with terminator = Some $2}}
} }
@ -398,7 +392,7 @@ instruction:
| assignment { Assign $1 } | assignment { Assign $1 }
| loop { Loop $1 } | loop { Loop $1 }
| proc_call { ProcCall $1 } | proc_call { ProcCall $1 }
| Skip { Skip $1 } | "skip" { Skip $1 }
| record_patch { RecordPatch $1 } | record_patch { RecordPatch $1 }
| map_patch { MapPatch $1 } | map_patch { MapPatch $1 }
| set_patch { SetPatch $1 } | set_patch { SetPatch $1 }
@ -406,7 +400,7 @@ instruction:
| set_remove { SetRemove $1 } | set_remove { SetRemove $1 }
set_remove: set_remove:
Remove expr From Set path { "remove" expr "from" "set" path {
let region = cover $1 (path_to_region $5) in let region = cover $1 (path_to_region $5) in
let value = { let value = {
kwd_remove = $1; kwd_remove = $1;
@ -417,7 +411,7 @@ set_remove:
in {region; value} } in {region; value} }
map_remove: map_remove:
Remove expr From Map path { "remove" expr "from" "map" path {
let region = cover $1 (path_to_region $5) in let region = cover $1 (path_to_region $5) in
let value = { let value = {
kwd_remove = $1; kwd_remove = $1;
@ -428,7 +422,7 @@ map_remove:
in {region; value} } in {region; value} }
set_patch: set_patch:
Patch path With ne_injection(Set,expr) { "patch" path "with" ne_injection("set",expr) {
let region = cover $1 $4.region in let region = cover $1 $4.region in
let value = { let value = {
kwd_patch = $1; kwd_patch = $1;
@ -438,7 +432,7 @@ set_patch:
in {region; value} } in {region; value} }
map_patch: map_patch:
Patch path With ne_injection(Map,binding) { "patch" path "with" ne_injection("map",binding) {
let region = cover $1 $4.region in let region = cover $1 $4.region in
let value = { let value = {
kwd_patch = $1; kwd_patch = $1;
@ -448,7 +442,7 @@ map_patch:
in {region; value} } in {region; value} }
injection(Kind,element): injection(Kind,element):
Kind sep_or_term_list(element,SEMI) End { Kind sep_or_term_list(element,";") "end" {
let elements, terminator = $2 in let elements, terminator = $2 in
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
@ -458,7 +452,7 @@ injection(Kind,element):
closing = End $3} closing = End $3}
in {region; value} in {region; value}
} }
| Kind End { | Kind "end" {
let region = cover $1 $2 let region = cover $1 $2
and value = { and value = {
opening = Kwd $1; opening = Kwd $1;
@ -467,7 +461,7 @@ injection(Kind,element):
closing = End $2} closing = End $2}
in {region; value} in {region; value}
} }
| Kind LBRACKET sep_or_term_list(element,SEMI) RBRACKET { | Kind "[" sep_or_term_list(element,";") "]" {
let elements, terminator = $3 in let elements, terminator = $3 in
let region = cover $1 $4 let region = cover $1 $4
and value = { and value = {
@ -477,7 +471,7 @@ injection(Kind,element):
closing = RBracket $4} closing = RBracket $4}
in {region; value} in {region; value}
} }
| Kind LBRACKET RBRACKET { | Kind "[" "]" {
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
opening = KwdBracket ($1,$2); opening = KwdBracket ($1,$2);
@ -487,7 +481,7 @@ injection(Kind,element):
in {region; value} } in {region; value} }
ne_injection(Kind,element): ne_injection(Kind,element):
Kind sep_or_term_list(element,SEMI) End { Kind sep_or_term_list(element,";") "end" {
let ne_elements, terminator = $2 in let ne_elements, terminator = $2 in
let region = cover $1 $3 let region = cover $1 $3
and value = { and value = {
@ -497,7 +491,7 @@ ne_injection(Kind,element):
closing = End $3} closing = End $3}
in {region; value} in {region; value}
} }
| Kind LBRACKET sep_or_term_list(element,SEMI) RBRACKET { | Kind "[" sep_or_term_list(element,";") "]" {
let ne_elements, terminator = $3 in let ne_elements, terminator = $3 in
let region = cover $1 $4 let region = cover $1 $4
and value = { and value = {
@ -505,11 +499,10 @@ ne_injection(Kind,element):
ne_elements; ne_elements;
terminator; terminator;
closing = RBracket $4} closing = RBracket $4}
in {region; value} in {region; value} }
}
binding: binding:
expr ARROW expr { expr "->" expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -520,7 +513,7 @@ binding:
in {region; value} } in {region; value} }
record_patch: record_patch:
Patch path With ne_injection(Record,field_assignment) { "patch" path "with" ne_injection("record",field_assignment) {
let region = cover $1 $4.region in let region = cover $1 $4.region in
let value = { let value = {
kwd_patch = $1; kwd_patch = $1;
@ -533,7 +526,7 @@ proc_call:
fun_call { $1 } fun_call { $1 }
conditional: conditional:
If expr Then if_clause option(SEMI) Else if_clause { "if" expr "then" if_clause ";"? "else" if_clause {
let region = cover $1 (if_clause_to_region $7) in let region = cover $1 (if_clause_to_region $7) in
let value : conditional = { let value : conditional = {
kwd_if = $1; kwd_if = $1;
@ -552,7 +545,7 @@ if_clause:
clause_block: clause_block:
block { block {
LongBlock $1 } LongBlock $1 }
| LBRACE sep_or_term_list(statement,SEMI) RBRACE { | "{" sep_or_term_list(statement,";") "}" {
let region = cover $1 $3 in let region = cover $1 $3 in
let value = { let value = {
lbrace = $1; lbrace = $1;
@ -564,7 +557,7 @@ case_instr:
case(if_clause) { $1 if_clause_to_region } case(if_clause) { $1 if_clause_to_region }
case(rhs): case(rhs):
Case expr Of option(VBAR) cases(rhs) End { "case" expr "of" "|"? cases(rhs) "end" {
fun rhs_to_region -> fun rhs_to_region ->
let region = cover $1 $6 in let region = cover $1 $6 in
let value = { let value = {
@ -576,7 +569,7 @@ case(rhs):
closing = End $6} closing = End $6}
in {region; value} in {region; value}
} }
| Case expr Of LBRACKET option(VBAR) cases(rhs) RBRACKET { | "case" expr "of" "[" "|"? cases(rhs) "]" {
fun rhs_to_region -> fun rhs_to_region ->
let region = cover $1 $7 in let region = cover $1 $7 in
let value = { let value = {
@ -589,7 +582,7 @@ case(rhs):
in {region; value} } in {region; value} }
cases(rhs): cases(rhs):
nsepseq(case_clause(rhs),VBAR) { nsepseq(case_clause(rhs),"|") {
fun rhs_to_region -> fun rhs_to_region ->
let mk_clause pre_clause = pre_clause rhs_to_region in let mk_clause pre_clause = pre_clause rhs_to_region in
let value = Utils.nsepseq_map mk_clause $1 in let value = Utils.nsepseq_map mk_clause $1 in
@ -597,7 +590,7 @@ cases(rhs):
in {region; value} } in {region; value} }
case_clause(rhs): case_clause(rhs):
pattern ARROW rhs { pattern "->" rhs {
fun rhs_to_region -> fun rhs_to_region ->
let start = pattern_to_region $1 in let start = pattern_to_region $1 in
let region = cover start (rhs_to_region $3) let region = cover start (rhs_to_region $3)
@ -605,7 +598,7 @@ case_clause(rhs):
in {region; value} } in {region; value} }
assignment: assignment:
lhs ASS rhs { lhs ":=" rhs {
let stop = rhs_to_region $3 in let stop = rhs_to_region $3 in
let region = cover (lhs_to_region $1) stop let region = cover (lhs_to_region $1) stop
and value = {lhs = $1; assign = $2; rhs = $3} and value = {lhs = $1; assign = $2; rhs = $3}
@ -623,7 +616,7 @@ loop:
| for_loop { $1 } | for_loop { $1 }
while_loop: while_loop:
While expr block { "while" expr block {
let region = cover $1 $3.region let region = cover $1 $3.region
and value = { and value = {
kwd_while = $1; kwd_while = $1;
@ -632,7 +625,7 @@ while_loop:
in While {region; value} } in While {region; value} }
for_loop: for_loop:
For var_assign To expr block { "for" var_assign "to" expr block {
let region = cover $1 $5.region in let region = cover $1 $5.region in
let value = { let value = {
kwd_for = $1; kwd_for = $1;
@ -642,8 +635,7 @@ for_loop:
block = $5} block = $5}
in For (ForInt {region; value}) in For (ForInt {region; value})
} }
| For var option(arrow_clause) | "for" var arrow_clause? "in" collection expr block {
In collection expr block {
let region = cover $1 $7.region in let region = cover $1 $7.region in
let value = { let value = {
kwd_for = $1; kwd_for = $1;
@ -656,18 +648,18 @@ for_loop:
in For (ForCollect {region; value}) } in For (ForCollect {region; value}) }
collection: collection:
Map { Map $1 } "map" { Map $1 }
| Set { Set $1 } | "set" { Set $1 }
| List { List $1 } | "list" { List $1 }
var_assign: var_assign:
var ASS expr { var ":=" expr {
let region = cover $1.region (expr_to_region $3) let region = cover $1.region (expr_to_region $3)
and value = {name = $1; assign = $2; expr = $3} and value = {name = $1; assign = $2; expr = $3}
in {region; value} } in {region; value} }
arrow_clause: arrow_clause:
ARROW var { $1,$2 } "->" var { $1,$2 }
(* Expressions *) (* Expressions *)
@ -681,7 +673,7 @@ expr:
| fun_expr { EFun $1 } | fun_expr { EFun $1 }
cond_expr: cond_expr:
If expr Then expr option(SEMI) Else expr { "if" expr "then" expr ";"? "else" expr {
let region = cover $1 (expr_to_region $7) in let region = cover $1 (expr_to_region $7) in
let value : cond_expr = { let value : cond_expr = {
kwd_if = $1; kwd_if = $1;
@ -694,7 +686,7 @@ cond_expr:
in ECond {region; value} } in ECond {region; value} }
disj_expr: disj_expr:
disj_expr Or conj_expr { disj_expr "or" conj_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -704,7 +696,7 @@ disj_expr:
| conj_expr { $1 } | conj_expr { $1 }
conj_expr: conj_expr:
conj_expr And set_membership { conj_expr "and" set_membership {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -714,7 +706,7 @@ conj_expr:
| set_membership { $1 } | set_membership { $1 }
set_membership: set_membership:
core_expr Contains set_membership { core_expr "contains" set_membership {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop in let region = cover start stop in
@ -727,42 +719,42 @@ set_membership:
| comp_expr { $1 } | comp_expr { $1 }
comp_expr: comp_expr:
comp_expr LT cat_expr { comp_expr "<" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in ELogic (CompExpr (Lt {region; value})) in ELogic (CompExpr (Lt {region; value}))
} }
| comp_expr LE cat_expr { | comp_expr "<=" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in ELogic (CompExpr (Leq {region; value})) in ELogic (CompExpr (Leq {region; value}))
} }
| comp_expr GT cat_expr { | comp_expr ">" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in ELogic (CompExpr (Gt {region; value})) in ELogic (CompExpr (Gt {region; value}))
} }
| comp_expr GE cat_expr { | comp_expr ">=" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in ELogic (CompExpr (Geq {region; value})) in ELogic (CompExpr (Geq {region; value}))
} }
| comp_expr EQ cat_expr { | comp_expr "=" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in ELogic (CompExpr (Equal {region; value})) in ELogic (CompExpr (Equal {region; value}))
} }
| comp_expr NE cat_expr { | comp_expr "=/=" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -772,7 +764,7 @@ comp_expr:
| cat_expr { $1 } | cat_expr { $1 }
cat_expr: cat_expr:
cons_expr CAT cat_expr { cons_expr "^" cat_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -782,7 +774,7 @@ cat_expr:
| cons_expr { $1 } | cons_expr { $1 }
cons_expr: cons_expr:
add_expr CONS cons_expr { add_expr "#" cons_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -792,14 +784,14 @@ cons_expr:
| add_expr { $1 } | add_expr { $1 }
add_expr: add_expr:
add_expr PLUS mult_expr { add_expr "+" mult_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in EArith (Add {region; value}) in EArith (Add {region; value})
} }
| add_expr MINUS mult_expr { | add_expr "-" mult_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -809,21 +801,21 @@ add_expr:
| mult_expr { $1 } | mult_expr { $1 }
mult_expr: mult_expr:
mult_expr TIMES unary_expr { mult_expr "*" unary_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in EArith (Mult {region; value}) in EArith (Mult {region; value})
} }
| mult_expr SLASH unary_expr { | mult_expr "/" unary_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
and value = {arg1 = $1; op = $2; arg2 = $3} and value = {arg1 = $1; op = $2; arg2 = $3}
in EArith (Div {region; value}) in EArith (Div {region; value})
} }
| mult_expr Mod unary_expr { | mult_expr "mod" unary_expr {
let start = expr_to_region $1 let start = expr_to_region $1
and stop = expr_to_region $3 in and stop = expr_to_region $3 in
let region = cover start stop let region = cover start stop
@ -833,13 +825,13 @@ mult_expr:
| unary_expr { $1 } | unary_expr { $1 }
unary_expr: unary_expr:
MINUS core_expr { "-" core_expr {
let stop = expr_to_region $2 in let stop = expr_to_region $2 in
let region = cover $1 stop let region = cover $1 stop
and value = {op = $1; arg = $2} and value = {op = $1; arg = $2}
in EArith (Neg {region; value}) in EArith (Neg {region; value})
} }
| Not core_expr { | "not" core_expr {
let stop = expr_to_region $2 in let stop = expr_to_region $2 in
let region = cover $1 stop let region = cover $1 stop
and value = {op = $1; arg = $2} in and value = {op = $1; arg = $2} in
@ -848,74 +840,70 @@ unary_expr:
| core_expr { $1 } | core_expr { $1 }
core_expr: core_expr:
Int { EArith (Int $1) } "<int>" { EArith (Int $1) }
| Nat { EArith (Nat $1) } | "<nat>" { EArith (Nat $1) }
| Mutez { EArith (Mutez $1) } | "<mutez>" { EArith (Mutez $1) }
| var { EVar $1 } | var { EVar $1 }
| String { EString (String $1) } | "<string>" { EString (String $1) }
| Bytes { EBytes $1 } | "<bytes>" { EBytes $1 }
| False { ELogic (BoolExpr (False $1)) } | "False" { ELogic (BoolExpr (False $1)) }
| True { ELogic (BoolExpr (True $1)) } | "True" { ELogic (BoolExpr (True $1)) }
| Unit { EUnit $1 } | "Unit" { EUnit $1 }
| annot_expr { EAnnot $1 } | annot_expr { EAnnot $1 }
| tuple_expr { ETuple $1 } | tuple_expr { ETuple $1 }
| list_expr { EList $1 } | list_expr { EList $1 }
| C_None { EConstr (NoneExpr $1) } | "None" { EConstr (NoneExpr $1) }
| fun_call_or_par_or_projection { $1 } | fun_call_or_par_or_projection { $1 }
| map_expr { EMap $1 } | map_expr { EMap $1 }
| set_expr { ESet $1 } | set_expr { ESet $1 }
| record_expr { ERecord $1 } | record_expr { ERecord $1 }
| Constr arguments { | "<constr>" arguments {
let region = cover $1.region $2.region in let region = cover $1.region $2.region in
EConstr (ConstrApp {region; value = $1, Some $2}) EConstr (ConstrApp {region; value = $1, Some $2})
} }
| Constr { | "<constr>" {
EConstr (ConstrApp {region=$1.region; value = $1,None}) EConstr (ConstrApp {region=$1.region; value = $1,None})
} }
| C_Some arguments { | "Some" arguments {
let region = cover $1 $2.region in let region = cover $1 $2.region in
EConstr (SomeApp {region; value = $1,$2}) } EConstr (SomeApp {region; value = $1,$2}) }
fun_call_or_par_or_projection: fun_call_or_par_or_projection:
| par(expr) option(arguments) { par(expr) arguments? {
let parenthesized = EPar $1 in let parenthesized = EPar $1 in
match $2 with match $2 with
| None -> parenthesized None -> parenthesized
| Some args -> ( | Some args ->
let region_1 = $1.region in let region_1 = $1.region in
let region = cover region_1 args.region in let region = cover region_1 args.region in
ECall {region; value = parenthesized,args} ECall {region; value = parenthesized,args}
)
} }
| projection option(arguments) { | projection arguments? {
let project = EProj $1 in let project = EProj $1 in
match $2 with match $2 with
| None -> project None -> project
| Some args -> ( | Some args ->
let region_1 = $1.region in let region_1 = $1.region in
let region = cover region_1 args.region in let region = cover region_1 args.region
ECall {region; value = project,args} in ECall {region; value = project,args}
)
} }
| fun_call { ECall $1 } | fun_call { ECall $1 }
annot_expr: annot_expr:
LPAR disj_expr COLON type_expr RPAR { "(" disj_expr ":" type_expr ")" {
let start = expr_to_region $2 let start = expr_to_region $2
and stop = type_expr_to_region $4 in and stop = type_expr_to_region $4 in
let region = cover start stop let region = cover start stop
and value = ($2 , $4) and value = $2, $4
in {region; value} in {region; value} }
}
set_expr: set_expr:
injection(Set,expr) { SetInj $1 } injection("set",expr) { SetInj $1 }
map_expr: map_expr:
map_lookup { MapLookUp $1 } map_lookup { MapLookUp $1 }
| injection(Map,binding) { MapInj $1 } | injection("map",binding) { MapInj $1 }
| injection(BigMap,binding) { BigMapInj $1 } | injection("big_map",binding) { BigMapInj $1 }
map_lookup: map_lookup:
path brackets(expr) { path brackets(expr) {
@ -928,7 +916,7 @@ path:
| projection { Path $1 } | projection { Path $1 }
projection: projection:
struct_name DOT nsepseq(selection,DOT) { struct_name "." nsepseq(selection,".") {
let stop = nsepseq_to_region selection_to_region $3 in let stop = nsepseq_to_region selection_to_region $3 in
let region = cover $1.region stop let region = cover $1.region stop
and value = { and value = {
@ -939,10 +927,10 @@ projection:
selection: selection:
field_name { FieldName $1 } field_name { FieldName $1 }
| Int { Component $1 } | "<int>" { Component $1 }
record_expr: record_expr:
Record sep_or_term_list(field_assignment,SEMI) End { "record" sep_or_term_list(field_assignment,";") "end" {
let ne_elements, terminator = $2 in let ne_elements, terminator = $2 in
let region = cover $1 $3 let region = cover $1 $3
and value : field_assign AST.reg ne_injection = { and value : field_assign AST.reg ne_injection = {
@ -952,7 +940,7 @@ record_expr:
closing = End $3} closing = End $3}
in {region; value} in {region; value}
} }
| Record LBRACKET sep_or_term_list(field_assignment,SEMI) RBRACKET { | "record" "[" sep_or_term_list(field_assignment,";") "]" {
let ne_elements, terminator = $3 in let ne_elements, terminator = $3 in
let region = cover $1 $4 let region = cover $1 $4
and value : field_assign AST.reg ne_injection = { and value : field_assign AST.reg ne_injection = {
@ -963,7 +951,7 @@ record_expr:
in {region; value} } in {region; value} }
field_assignment: field_assignment:
field_name EQ expr { field_name "=" expr {
let region = cover $1.region (expr_to_region $3) let region = cover $1.region (expr_to_region $3)
and value = { and value = {
field_name = $1; field_name = $1;
@ -980,59 +968,60 @@ tuple_expr:
par(tuple_comp) { $1 } par(tuple_comp) { $1 }
tuple_comp: tuple_comp:
expr COMMA nsepseq(expr,COMMA) { expr "," nsepseq(expr,",") {
Utils.nsepseq_cons $1 $2 $3 } Utils.nsepseq_cons $1 $2 $3 }
arguments: arguments:
par(nsepseq(expr,COMMA)) { $1 } par(nsepseq(expr,",")) { $1 }
list_expr: list_expr:
injection(List,expr) { EListComp $1 } injection("list",expr) { EListComp $1 }
| Nil { ENil $1 } | "nil" { ENil $1 }
(* Patterns *) (* Patterns *)
pattern: pattern:
core_pattern CONS nsepseq(core_pattern,CONS) { core_pattern "#" nsepseq(core_pattern,"#") {
let value = Utils.nsepseq_cons $1 $2 $3 in let value = Utils.nsepseq_cons $1 $2 $3 in
let region = nsepseq_to_region pattern_to_region value let region = nsepseq_to_region pattern_to_region value
in PList (PCons {region; value}) } in PList (PCons {region; value})
}
| core_pattern { $1 } | core_pattern { $1 }
core_pattern: core_pattern:
var { PVar $1 } var { PVar $1 }
| WILD { PWild $1 } | "_" { PWild $1 }
| Int { PInt $1 } | "<int>" { PInt $1 }
| Nat { PNat $1 } | "<nat>" { PNat $1 }
| Bytes { PBytes $1 } | "<bytes>" { PBytes $1 }
| String { PString $1 } | "<string>" { PString $1 }
| list_pattern { PList $1 } | list_pattern { PList $1 }
| tuple_pattern { PTuple $1 } | tuple_pattern { PTuple $1 }
| constr_pattern { PConstr $1 } | constr_pattern { PConstr $1 }
list_pattern: list_pattern:
injection(List,core_pattern) { PListComp $1 } injection("list",core_pattern) { PListComp $1 }
| Nil { PNil $1 } | "nil" { PNil $1 }
| par(cons_pattern) { PParCons $1 } | par(cons_pattern) { PParCons $1 }
cons_pattern: cons_pattern:
core_pattern CONS pattern { $1,$2,$3 } core_pattern "#" pattern { $1,$2,$3 }
tuple_pattern: tuple_pattern:
par(nsepseq(core_pattern,COMMA)) { $1 } par(nsepseq(core_pattern,",")) { $1 }
constr_pattern: constr_pattern:
Unit { PUnit $1 } "Unit" { PUnit $1 }
| False { PFalse $1 } | "False" { PFalse $1 }
| True { PTrue $1 } | "True" { PTrue $1 }
| C_None { PNone $1 } | "None" { PNone $1 }
| C_Some par(core_pattern) { | "Some" par(core_pattern) {
let region = cover $1 $2.region let region = cover $1 $2.region
in PSomeApp {region; value = $1,$2} in PSomeApp {region; value = $1,$2}
} }
| Constr tuple_pattern { | "<constr>" tuple_pattern {
let region = cover $1.region $2.region let region = cover $1.region $2.region in
in PConstrApp {region; value = $1, Some $2} PConstrApp {region; value = $1, Some $2}
} }
| Constr { | "<constr>" {
PConstrApp {region=$1.region; value=$1,None} } PConstrApp {region=$1.region; value=$1,None} }

2
src/passes/1-parser/pascaligo/Stubs/Simple_utils.ml Normal file
View File

@ -0,0 +1,2 @@
module Region = Region
module Pos = Pos

0
src/passes/1-parser/reasonligo/.LexerMain.tag Normal file
View File

1
src/passes/1-parser/reasonligo/.Parser.mly.tag Normal file
View File

@ -0,0 +1 @@
--explain --external-tokens LexToken --base Parser ParToken.mly

0
src/passes/1-parser/reasonligo/.ParserMain.tag Normal file
View File

25
src/passes/1-parser/reasonligo/.links Normal file
View File

@ -0,0 +1,25 @@
$HOME/git/OCaml-build/Makefile
$HOME/git/OCaml-build/Makefile.cfg
$HOME/git/ligo/vendors/ligo-utils/simple-utils/pos.mli
$HOME/git/ligo/vendors/ligo-utils/simple-utils/pos.ml
$HOME/git/ligo/vendors/ligo-utils/simple-utils/region.mli
$HOME/git/ligo/vendors/ligo-utils/simple-utils/region.ml
../shared/Lexer.mli
../shared/Lexer.mll
../shared/Error.mli
../shared/EvalOpt.ml
../shared/EvalOpt.mli
../shared/FQueue.ml
../shared/FQueue.mli
../shared/LexerLog.mli
../shared/LexerLog.ml
../shared/Markup.ml
../shared/Markup.mli
../shared/Utils.mli
../shared/Utils.ml
Stubs/Simple_utils.ml
Stubs/Parser_cameligo.ml
../cameligo/AST.mli
../cameligo/AST.ml
../cameligo/ParserLog.mli
../cameligo/ParserLog.ml

8
src/passes/1-parser/reasonligo/LexToken.mli
View File

@ -56,7 +56,7 @@ type t =
| VBAR of Region.t (* "|" *) | VBAR of Region.t (* "|" *)
| COLON of Region.t (* ":" *) | COLON of Region.t (* ":" *)
| DOT of Region.t (* "." *) | DOT of Region.t (* "." *)
| DOTDOTDOT of Region.t (* "..." *) | ELLIPSIS of Region.t (* "..." *)
(* Wildcard *) (* Wildcard *)
@ -71,11 +71,11 @@ type t =
| GT of Region.t (* ">" *) | GT of Region.t (* ">" *)
| LE of Region.t (* "=<" *) | LE of Region.t (* "=<" *)
| GE of Region.t (* ">=" *) | GE of Region.t (* ">=" *)
| ARROW of Region.t (* "=>" *) | ARROW of Region.t (* "=>" *)
| BOOL_OR of Region.t (* "||" *) | BOOL_OR of Region.t (* "||" *)
| BOOL_AND of Region.t (* "&&" *) | BOOL_AND of Region.t (* "&&" *)
| NOT of Region.t (* ! *) | NOT of Region.t (* ! *)
(* Identifiers, labels, numbers and strings *) (* Identifiers, labels, numbers and strings *)
@ -84,8 +84,8 @@ type t =
| Constr of string Region.reg | Constr of string Region.reg
| Int of (string * Z.t) Region.reg | Int of (string * Z.t) Region.reg
| Nat of (string * Z.t) Region.reg | Nat of (string * Z.t) Region.reg
| Mtz of (string * Z.t) Region.reg | Mutez of (string * Z.t) Region.reg
| Str of string Region.reg | String of string Region.reg
| Bytes of (string * Hex.t) Region.reg | Bytes of (string * Hex.t) Region.reg
(* Keywords *) (* Keywords *)

30
src/passes/1-parser/reasonligo/LexToken.mll
View File

@ -38,7 +38,7 @@ type t =
| VBAR of Region.t (* "|" *) | VBAR of Region.t (* "|" *)
| COLON of Region.t (* ":" *) | COLON of Region.t (* ":" *)
| DOT of Region.t (* "." *) | DOT of Region.t (* "." *)
| DOTDOTDOT of Region.t (* "..." *) | ELLIPSIS of Region.t (* "..." *)
(* Wildcard *) (* Wildcard *)
@ -66,8 +66,8 @@ type t =
| Constr of string Region.reg | Constr of string Region.reg
| Int of (string * Z.t) Region.reg | Int of (string * Z.t) Region.reg
| Nat of (string * Z.t) Region.reg | Nat of (string * Z.t) Region.reg
| Mtz of (string * Z.t) Region.reg | Mutez of (string * Z.t) Region.reg
| Str of string Region.reg | String of string Region.reg
| Bytes of (string * Hex.t) Region.reg | Bytes of (string * Hex.t) Region.reg
(* Keywords *) (* Keywords *)
@ -110,7 +110,7 @@ let proj_token = function
| VBAR region -> region, "VBAR" | VBAR region -> region, "VBAR"
| COLON region -> region, "COLON" | COLON region -> region, "COLON"
| DOT region -> region, "DOT" | DOT region -> region, "DOT"
| DOTDOTDOT region -> region, "DOTDOTDOT" | ELLIPSIS region -> region, "ELLIPSIS"
| WILD region -> region, "WILD" | WILD region -> region, "WILD"
| EQ region -> region, "EQ" | EQ region -> region, "EQ"
| EQEQ region -> region, "EQEQ" | EQEQ region -> region, "EQEQ"
@ -130,10 +130,10 @@ let proj_token = function
region, sprintf "Int (\"%s\", %s)" s (Z.to_string n) region, sprintf "Int (\"%s\", %s)" s (Z.to_string n)
| Nat Region.{region; value = s,n} -> | Nat Region.{region; value = s,n} ->
region, sprintf "Nat (\"%s\", %s)" s (Z.to_string n) region, sprintf "Nat (\"%s\", %s)" s (Z.to_string n)
| Mtz Region.{region; value = s,n} -> | Mutez Region.{region; value = s,n} ->
region, sprintf "Mutez (\"%s\", %s)" s (Z.to_string n) region, sprintf "Mutez (\"%s\", %s)" s (Z.to_string n)
| Str Region.{region; value} -> | String Region.{region; value} ->
region, sprintf "Str %s" value region, sprintf "String %s" value
| Bytes Region.{region; value = s,b} -> | Bytes Region.{region; value = s,b} ->
region, region,
sprintf "Bytes (\"%s\", \"0x%s\")" sprintf "Bytes (\"%s\", \"0x%s\")"
@ -169,7 +169,7 @@ let to_lexeme = function
| VBAR _ -> "|" | VBAR _ -> "|"
| COLON _ -> ":" | COLON _ -> ":"
| DOT _ -> "." | DOT _ -> "."
| DOTDOTDOT _ -> "..." | ELLIPSIS _ -> "..."
| WILD _ -> "_" | WILD _ -> "_"
| EQ _ -> "=" | EQ _ -> "="
| EQEQ _ -> "==" | EQEQ _ -> "=="
@ -185,8 +185,8 @@ let to_lexeme = function
| Constr id -> id.Region.value | Constr id -> id.Region.value
| Int i | Int i
| Nat i | Nat i
| Mtz i -> fst i.Region.value | Mutez i -> fst i.Region.value
| Str s -> s.Region.value | String s -> s.Region.value
| Bytes b -> fst b.Region.value | Bytes b -> fst b.Region.value
| Else _ -> "else" | Else _ -> "else"
| False _ -> "false" | False _ -> "false"
@ -346,7 +346,7 @@ let line_comment_start lexeme = lexeme = "//"
(* Smart constructors (injections) *) (* Smart constructors (injections) *)
let mk_string lexeme region = Str Region.{region; value=lexeme} let mk_string lexeme region = String Region.{region; value=lexeme}
let mk_bytes lexeme region = let mk_bytes lexeme region =
let norm = Str.(global_replace (regexp "_") "" lexeme) in let norm = Str.(global_replace (regexp "_") "" lexeme) in
@ -376,7 +376,7 @@ let mk_mutez lexeme region =
Z.of_string in Z.of_string in
if Z.equal z Z.zero && lexeme <> "0mutez" if Z.equal z Z.zero && lexeme <> "0mutez"
then Error Non_canonical_zero then Error Non_canonical_zero
else Ok (Mtz Region.{region; value = lexeme, z}) else Ok (Mutez Region.{region; value = lexeme, z})
let eof region = EOF region let eof region = EOF region
@ -408,7 +408,7 @@ let mk_sym lexeme region =
| ")" -> Ok (RPAR region) | ")" -> Ok (RPAR region)
(* Symbols specific to ReasonLIGO *) (* Symbols specific to ReasonLIGO *)
| "..."-> Ok (DOTDOTDOT region) | "..."-> Ok (ELLIPSIS region)
| "=>" -> Ok (ARROW region) | "=>" -> Ok (ARROW region)
| "==" -> Ok (EQEQ region) | "==" -> Ok (EQEQ region)
| "!" -> Ok (NOT region) | "!" -> Ok (NOT region)
@ -432,7 +432,7 @@ let mk_constr lexeme region = mk_constr' lexeme region lexicon
(* Predicates *) (* Predicates *)
let is_string = function let is_string = function
Str _ -> true String _ -> true
| _ -> false | _ -> false
let is_bytes = function let is_bytes = function
@ -483,7 +483,7 @@ let is_sym = function
| VBAR _ | VBAR _
| COLON _ | COLON _
| DOT _ | DOT _
| DOTDOTDOT _ | ELLIPSIS _
| WILD _ | WILD _
| EQ _ | EQ _
| EQEQ _ | EQEQ _

95
src/passes/1-parser/reasonligo/ParToken.mly
View File

@ -1,73 +1,72 @@
%{ %{
%} %}
(* Tokens (mirroring thise defined in module LexToken) *) (* Tokens (mirroring those defined in module LexToken) *)
(* Literals *) (* Literals *)
%token <string Region.reg> Ident %token <string Region.reg> Ident "<ident>"
%token <string Region.reg> Constr %token <string Region.reg> Constr "<constr>"
%token <string Region.reg> Str %token <string Region.reg> String "<string>"
%token <(string * Z.t) Region.reg> Int %token <(string * Z.t) Region.reg> Int "<int>"
%token <(string * Z.t) Region.reg> Nat %token <(string * Z.t) Region.reg> Nat "<nat>"
%token <(string * Z.t) Region.reg> Mtz %token <(string * Z.t) Region.reg> Mutez "<mutez>"
(* Symbols *) (* Symbols *)
%token <Region.t> MINUS %token <Region.t> MINUS "-"
%token <Region.t> PLUS %token <Region.t> PLUS "+"
%token <Region.t> SLASH %token <Region.t> SLASH "/"
%token <Region.t> TIMES %token <Region.t> TIMES "*"
%token <Region.t> LPAR %token <Region.t> LPAR "("
%token <Region.t> RPAR %token <Region.t> RPAR ")"
%token <Region.t> LBRACKET %token <Region.t> LBRACKET "["
%token <Region.t> RBRACKET %token <Region.t> RBRACKET "]"
%token <Region.t> LBRACE %token <Region.t> LBRACE "{"
%token <Region.t> RBRACE %token <Region.t> RBRACE "}"
%token <Region.t> CAT %token <Region.t> CAT "++"
%token <Region.t> DOT %token <Region.t> DOT "."
%token <Region.t> DOTDOTDOT %token <Region.t> ELLIPSIS "..."
%token <Region.t> COMMA %token <Region.t> COMMA ","
%token <Region.t> SEMI %token <Region.t> SEMI ";"
%token <Region.t> COLON %token <Region.t> COLON ":"
%token <Region.t> VBAR %token <Region.t> VBAR "|"
%token <Region.t> WILD %token <Region.t> WILD "_"
%token <Region.t> EQ %token <Region.t> EQ "="
%token <Region.t> EQEQ %token <Region.t> EQEQ "=="
%token <Region.t> NE %token <Region.t> NE "!="
%token <Region.t> LT %token <Region.t> LT "<"
%token <Region.t> GT %token <Region.t> GT ">"
%token <Region.t> LE %token <Region.t> LE "<="
%token <Region.t> GE %token <Region.t> GE ">="
%token <Region.t> ARROW %token <Region.t> ARROW "=>"
%token <Region.t> NOT %token <Region.t> NOT "!"
%token <Region.t> BOOL_OR "||"
%token <Region.t> BOOL_OR %token <Region.t> BOOL_AND "&&"
%token <Region.t> BOOL_AND
(* Keywords *) (* Keywords *)
%token <Region.t> Else %token <Region.t> Else "else"
%token <Region.t> False %token <Region.t> False "false"
%token <Region.t> If %token <Region.t> If "if"
%token <Region.t> Let %token <Region.t> Let "let"
%token <Region.t> Switch %token <Region.t> Switch "switch"
%token <Region.t> Mod %token <Region.t> Mod "mod"
%token <Region.t> Or %token <Region.t> Or "or"
%token <Region.t> True %token <Region.t> True "true"
%token <Region.t> Type %token <Region.t> Type "type"
(* Data constructors *) (* Data constructors *)
%token <Region.t> C_None (* "None" *) %token <Region.t> C_None "None"
%token <Region.t> C_Some (* "Some" *) %token <Region.t> C_Some "Some"
(* Virtual tokens *) (* Virtual tokens *)

946
src/passes/1-parser/reasonligo/Parser.mly
View File

File diff suppressed because it is too large Load Diff

1
src/passes/1-parser/reasonligo/Stubs/Parser_cameligo.ml Normal file
View File

@ -0,0 +1 @@
module AST = AST

2
src/passes/1-parser/reasonligo/Stubs/Simple_utils.ml Normal file
View File

@ -0,0 +1,2 @@
module Region = Region
module Pos = Pos

11
src/passes/2-simplify/cameligo.ml
View File

@ -155,11 +155,10 @@ let rec pattern_to_typed_var : Raw.pattern -> _ = fun p ->
| Raw.PWild r -> ok (({ region = r ; value = "_" } : Raw.variable) , None) | Raw.PWild r -> ok (({ region = r ; value = "_" } : Raw.variable) , None)
| _ -> fail @@ wrong_pattern "typed variable" p | _ -> fail @@ wrong_pattern "typed variable" p
let rec expr_to_typed_expr : Raw.expr -> _ = fun e -> let rec expr_to_typed_expr : Raw.expr -> _ = function
match e with EPar e -> expr_to_typed_expr e.value.inside
| EPar e -> expr_to_typed_expr e.value.inside | EAnnot {value={inside=e,_,t; _}; _} -> ok (e, Some t)
| EAnnot a -> ok (fst a.value , Some (snd a.value)) | e -> ok (e , None)
| _ -> ok (e , None)
let patterns_to_var : Raw.pattern nseq -> _ = fun ps -> let patterns_to_var : Raw.pattern nseq -> _ = fun ps ->
match ps with match ps with
@ -266,7 +265,7 @@ let rec simpl_expression :
let%bind body = simpl_expression body in let%bind body = simpl_expression body in
return @@ e_let_in (Var.of_name variable.value , None) rhs' body return @@ e_let_in (Var.of_name variable.value , None) rhs' body
| Raw.EAnnot a -> | Raw.EAnnot a ->
let (expr , type_expr), loc = r_split a in let Raw.{inside=expr, _, type_expr; _}, loc = r_split a in
let%bind expr' = simpl_expression expr in let%bind expr' = simpl_expression expr in
let%bind type_expr' = simpl_type_expression type_expr in let%bind type_expr' = simpl_type_expression type_expr in
return @@ e_annotation ~loc expr' type_expr' return @@ e_annotation ~loc expr' type_expr'