mirror of
https://github.com/CatalaLang/catala.git
synced 2024-11-08 07:51:43 +03:00
a415355a39
The phantom polymorphic variant qualifying AST nodes is reversed: - previously, we were explicitely restricting each AST node to the passes where it belonged using a closed type (e.g. `[< dcalc | lcalc]`) - now, each node instead declares the "feature" it provides using an open type (e.g. `[> 'Exceptions ]`) - then the AST for a specific pass limits the features it allows with a closed type The result is that you can mix and match all features if you wish, even if the result is not a valid AST for any given pass. More interestingly, it's now easier to write a function that works on different ASTs at once (it's the inferred default if you don't write a type restriction). The opportunity was also taken to simplify the encoding of the operators, which don't need a second type parameter anymore.
78 lines
2.6 KiB
OCaml
78 lines
2.6 KiB
OCaml
(* This file is part of the Catala compiler, a specification language for tax
|
|
and social benefits computation rules. Copyright (C) 2021 Inria, contributor:
|
|
Denis Merigoux <denis.merigoux@inria.fr>
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
use this file except in compliance with the License. You may obtain a copy of
|
|
the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
License for the specific language governing permissions and limitations under
|
|
the License. *)
|
|
|
|
open Catala_utils
|
|
open Shared_ast
|
|
module D = Dcalc.Ast
|
|
module L = Lcalc.Ast
|
|
module FuncName = Uid.Gen ()
|
|
module VarName = Uid.Gen ()
|
|
|
|
let dead_value = VarName.fresh ("dead_value", Pos.no_pos)
|
|
let handle_default = FuncName.fresh ("handle_default", Pos.no_pos)
|
|
let handle_default_opt = FuncName.fresh ("handle_default_opt", Pos.no_pos)
|
|
|
|
type operator = [ `Monomorphic | `Polymorphic | `Resolved ] Shared_ast.operator
|
|
|
|
type expr = naked_expr Marked.pos
|
|
|
|
and naked_expr =
|
|
| EVar : VarName.t -> naked_expr
|
|
| EFunc : FuncName.t -> naked_expr
|
|
| EStruct : expr list * StructName.t -> naked_expr
|
|
| EStructFieldAccess : expr * StructField.t * StructName.t -> naked_expr
|
|
| EInj : expr * EnumConstructor.t * EnumName.t -> naked_expr
|
|
| EArray : expr list -> naked_expr
|
|
| ELit : L.lit -> naked_expr
|
|
| EApp : expr * expr list -> naked_expr
|
|
| EOp : operator -> naked_expr
|
|
|
|
type stmt =
|
|
| SInnerFuncDef of VarName.t Marked.pos * func
|
|
| SLocalDecl of VarName.t Marked.pos * typ
|
|
| SLocalDef of VarName.t Marked.pos * expr
|
|
| STryExcept of block * except * block
|
|
| SRaise of except
|
|
| SIfThenElse of expr * block * block
|
|
| SSwitch of
|
|
expr
|
|
* EnumName.t
|
|
* (block (* Statements corresponding to arm closure body*)
|
|
* (* Variable instantiated with enum payload *) VarName.t)
|
|
list (** Each block corresponds to one case of the enum *)
|
|
| SReturn of naked_expr
|
|
| SAssert of naked_expr
|
|
|
|
and block = stmt Marked.pos list
|
|
|
|
and func = {
|
|
func_params : (VarName.t Marked.pos * typ) list;
|
|
func_body : block;
|
|
}
|
|
|
|
type scope_body = {
|
|
scope_body_name : ScopeName.t;
|
|
scope_body_var : FuncName.t;
|
|
scope_body_func : func;
|
|
}
|
|
|
|
type code_item =
|
|
| SVar of { var : VarName.t; expr : expr }
|
|
| SFunc of { var : FuncName.t; func : func }
|
|
| SScope of scope_body
|
|
|
|
type program = { decl_ctx : decl_ctx; code_items : code_item list }
|