CatalaLang/catala
1
1
Fork 0
mirror of https://github.com/CatalaLang/catala.git synced 2024-09-19 16:28:12 +03:00
Code Issues Projects Releases Wiki Activity
8194abaf93
catala/compiler/desugared/name_resolution.ml

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1002 lines
35 KiB
OCaml
Raw Normal View History

Rework of the syntax trees
2020-06-22 17:16:55 +03:00
(* This file is part of the Catala compiler, a specification language for tax
and social benefits computation rules. Copyright (C) 2020 Inria, contributor:
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
Nicolas Chataing <nicolas.chataing@ens.fr> Denis Merigoux
<denis.merigoux@inria.fr>
Rework of the syntax trees
2020-06-22 17:16:55 +03:00
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. *)
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
(** Builds a context that allows for mapping each name to a precise uid, taking
lexical scopes into account *)
Rework of the syntax trees
2020-06-22 17:16:55 +03:00
Rename utils to catala_utils
2022-11-21 12:46:17 +03:00
open Catala_utils
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
open Shared_ast
Big code reorg with better dune config
2020-11-23 11:22:47 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** {1 Name resolution context} *)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
type unique_rulename = Ambiguous of Pos.t list | Unique of RuleName.t Mark.pos
Improve unlabeled exceptions: Default definitions and unlabeled exceptions in the same scope can now be defined in different code blocks
2021-01-22 07:47:48 +03:00
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
type scope_def_context = {
default_exception_rulename : unique_rulename option;
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
label_idmap : LabelName.t Ident.Map.t;
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
}
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
type scope_var_or_subscope =
| ScopeVar of ScopeVar.t
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
| SubScope of SubScopeName.t * ScopeName.t
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
type scope_context = {
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
var_idmap : scope_var_or_subscope Ident.Map.t;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** All variables, including scope variables and subscopes *)
Refactoring changes after @altgr's suggestions
2023-04-18 11:31:44 +03:00
scope_defs_contexts : scope_def_context Ast.ScopeDef.Map.t;
Add support for unlabeled exceptions when unambigous
2021-01-21 08:07:09 +03:00
(** What is the default rule to refer to for unnamed exceptions, if any *)
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
sub_scopes : ScopeName.Set.t;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** Other scopes referred to by this scope. Used for dependency analysis *)
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
}
(** Inside a scope, we distinguish between the variables and the subscopes. *)
Add function to translate an expression to a lambda term
2020-07-15 17:14:11 +03:00
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
type struct_context = typ StructField.Map.t
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Types of the fields of a struct *)
Enum and struct context to fill in name resolution
2020-12-04 18:40:17 +03:00
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
type enum_context = typ EnumConstructor.Map.t
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Types of the payloads of the cases of an enum *)
Enum and struct context to fill in name resolution
2020-12-04 18:40:17 +03:00
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
type var_sig = {
Same treatment for `typ` and `marked_typ`
2022-08-25 18:29:00 +03:00
var_sig_typ : typ;
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
var_sig_is_condition : bool;
Fix multi-argument scopedefs, improve error message positions This adds a few positions to the parser, and tweaks some others, vastly improving the reporting of some errors (inconsistent functions definitions, but also exceptions cycles, etc.)
2023-02-28 16:40:05 +03:00
var_sig_parameters :
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Uid.MarkedString.info * Shared_ast.typ) list Mark.pos option;
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
var_sig_io : Surface.Ast.scope_decl_context_io;
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
var_sig_states_idmap : StateName.t Ident.Map.t;
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
var_sig_states_list : StateName.t list;
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
}
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** Capitalised type names share a namespace on the user side, but may
correspond to only one of the following *)
type typedef =
| TStruct of StructName.t
| TEnum of EnumName.t
| TScope of ScopeName.t * scope_info (** Implicitly defined output struct *)
Separate typing and name resolution. Remove ECallerVar term
2020-07-15 18:47:16 +03:00
type context = {
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
path : Uid.Path.t;
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
typedefs : typedef Ident.Map.t;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** Gathers the names of the scopes, structs and enums *)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
field_idmap : StructField.t StructName.Map.t Ident.Map.t;
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** The names of the struct fields. Names of fields can be shared between
different structs *)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
constructor_idmap : EnumConstructor.t EnumName.Map.t Ident.Map.t;
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** The names of the enum constructors. Constructor names can be shared
between different enums *)
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
scopes : scope_context ScopeName.Map.t; (** For each scope, its context *)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
topdefs : TopdefName.t Ident.Map.t; (** Global definitions *)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
topdef_types : typ TopdefName.Map.t;
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
structs : struct_context StructName.Map.t;
(** For each struct, its context *)
enums : enum_context EnumName.Map.t; (** For each enum, its context *)
var_typs : var_sig ScopeVar.Map.t;
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
(** The signatures of each scope variable declared *)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
modules : context ModuleName.Map.t;
Separate typing and name resolution. Remove ECallerVar term
2020-07-15 18:47:16 +03:00
}
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Main context used throughout {!module: Surface.Desugaring} *)
(** {1 Helpers} *)
Separate typing and name resolution. Remove ECallerVar term
2020-07-15 18:47:16 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Temporary function raising an error message saying that a feature is not
supported yet *)
Restructured error handling
2020-08-07 13:51:51 +03:00
let raise_unsupported_feature (msg : string) (pos : Pos.t) =
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error pos "Unsupported feature: %s" msg
Restructured error handling
2020-08-07 13:51:51 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Function to call whenever an identifier used somewhere has not been declared
in the program previously *)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
let raise_unknown_identifier (msg : string) (ident : Ident.t Mark.pos) =
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error (Mark.get ident)
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
"@{<yellow>\"%s\"@}: unknown identifier %s" (Mark.remove ident) msg
Fill skeleton for context formation
2020-07-16 15:46:40 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Gets the type associated to an uid *)
Same treatment for `typ` and `marked_typ`
2022-08-25 18:29:00 +03:00
let get_var_typ (ctxt : context) (uid : ScopeVar.t) : typ =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
(ScopeVar.Map.find uid ctxt.var_typs).var_sig_typ
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
let is_var_cond (ctxt : context) (uid : ScopeVar.t) : bool =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
(ScopeVar.Map.find uid ctxt.var_typs).var_sig_is_condition
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let get_var_io (ctxt : context) (uid : ScopeVar.t) :
Surface.Ast.scope_decl_context_io =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
(ScopeVar.Map.find uid ctxt.var_typs).var_sig_io
Reformat some code
2020-08-03 23:03:05 +03:00
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let get_scope_context (ctxt : context) (scope : ScopeName.t) : scope_context =
let rec remove_common_prefix curpath scpath =
match curpath, scpath with
| m1 :: cp, m2 :: sp when ModuleName.equal m1 m2 ->
remove_common_prefix cp sp
| _ -> scpath
in
let path = remove_common_prefix ctxt.path (ScopeName.path scope) in
let ctxt =
List.fold_left (fun ctx m -> ModuleName.Map.find m ctx.modules) ctxt path
in
ScopeName.Map.find scope ctxt.scopes
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Get the variable uid inside the scope given in argument *)
let get_var_uid
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(scope_uid : ScopeName.t)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(ctxt : context)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
((x, pos) : Ident.t Mark.pos) : ScopeVar.t =
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope = get_scope_context ctxt scope_uid in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt x scope.var_idmap with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| Some (ScopeVar uid) -> uid
| _ ->
Small tweak to make tutorial more climactic
2021-01-08 00:38:56 +03:00
raise_unknown_identifier
Add some helper functions in a wrapper `Map` module and use them throughout. No more `List.map fst (Map.bindings m)` ! Also adds some facilities for direct formatting without going through a list.
2023-07-12 12:48:46 +03:00
(Format.asprintf "for a variable of scope %a" ScopeName.format scope_uid)
Small tweak to make tutorial more climactic
2021-01-08 00:38:56 +03:00
(x, pos)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Get the subscope uid inside the scope given in argument *)
let get_subscope_uid
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(scope_uid : ScopeName.t)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(ctxt : context)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
((y, pos) : Ident.t Mark.pos) : SubScopeName.t =
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope = get_scope_context ctxt scope_uid in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt y scope.var_idmap with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| Some (SubScope (sub_uid, _sub_id)) -> sub_uid
| _ -> raise_unknown_identifier "for a subscope of this scope" (y, pos)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** [is_subscope_uid scope_uid ctxt y] returns true if [y] belongs to the
subscopes of [scope_uid]. *)
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
let is_subscope_uid (scope_uid : ScopeName.t) (ctxt : context) (y : Ident.t) :
bool =
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope = get_scope_context ctxt scope_uid in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt y scope.var_idmap with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| Some (SubScope _) -> true
| _ -> false
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Checks if the var_uid belongs to the scope scope_uid *)
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
let belongs_to (ctxt : context) (uid : ScopeVar.t) (scope_uid : ScopeName.t) :
bool =
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope = get_scope_context ctxt scope_uid in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.exists
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(fun _ -> function
| ScopeVar var_uid -> ScopeVar.equal uid var_uid
| _ -> false)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
scope.var_idmap
(** Retrieves the type of a scope definition from the context *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let get_def_typ (ctxt : context) (def : Ast.ScopeDef.t) : typ =
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
match def with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Ast.ScopeDef.SubScopeVar (_, x, _)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(* we don't need to look at the subscope prefix because [x] is already the uid
referring back to the original subscope *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Ast.ScopeDef.Var (x, _) ->
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
get_var_typ ctxt x
Fix multi-argument scopedefs, improve error message positions This adds a few positions to the parser, and tweaks some others, vastly improving the reporting of some errors (inconsistent functions definitions, but also exceptions cycles, etc.)
2023-02-28 16:40:05 +03:00
(** Retrieves the type of a scope definition from the context *)
let get_params (ctxt : context) (def : Ast.ScopeDef.t) :
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Uid.MarkedString.info * typ) list Mark.pos option =
Fix multi-argument scopedefs, improve error message positions This adds a few positions to the parser, and tweaks some others, vastly improving the reporting of some errors (inconsistent functions definitions, but also exceptions cycles, etc.)
2023-02-28 16:40:05 +03:00
match def with
| Ast.ScopeDef.SubScopeVar (_, x, _)
(* we don't need to look at the subscope prefix because [x] is already the uid
referring back to the original subscope *)
| Ast.ScopeDef.Var (x, _) ->
(ScopeVar.Map.find x ctxt.var_typs).var_sig_parameters
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let is_def_cond (ctxt : context) (def : Ast.ScopeDef.t) : bool =
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
match def with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Ast.ScopeDef.SubScopeVar (_, x, _)
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
(* we don't need to look at the subscope prefix because [x] is already the uid
referring back to the original subscope *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Ast.ScopeDef.Var (x, _) ->
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
is_var_cond ctxt x
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let get_enum ctxt id =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find (Mark.remove id) ctxt.typedefs with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| TEnum id -> id
| TStruct sid ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get id;
Some "Structure defined at", Mark.get (StructName.get_info sid);
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
]
"Expecting an enum, but found a structure"
| TScope (sid, _) ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get id;
Some "Scope defined at", Mark.get (ScopeName.get_info sid);
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
]
"Expecting an enum, but found a scope"
Specialise the Map.Not_found exception raised by Map.find ... and add a custom printer Since this is a very common bug, this patch should gain us a lot of time when debugging uncaught Not_found errors, because the element not found can now be printed straight away without the need for further debugging. The small cost is that one should remember to catch the correct specialised `Foo.Map.Not_found _` exception rather than the standard `Not_found` (which would type-check but not catch the exception). Using `find_opt` should be preferred anyway. Note that the other functions from the module `Map` that raise `Not_found` are not affected ; these functions are `choose`, `min/max_binding`, `find_first/last` which either take a predicate or fail on the empty map, so it wouldn't make sense for them (and we probably don't use them much).
2023-08-15 17:57:52 +03:00
| exception Ident.Map.Not_found _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error (Mark.get id) "No enum named %s found"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove id)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let get_struct ctxt id =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find (Mark.remove id) ctxt.typedefs with
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
| TStruct id | TScope (_, { out_struct_name = id; _ }) -> id
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| TEnum eid ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get id;
Some "Enum defined at", Mark.get (EnumName.get_info eid);
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
]
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
"Expecting a struct, but found an enum"
Specialise the Map.Not_found exception raised by Map.find ... and add a custom printer Since this is a very common bug, this patch should gain us a lot of time when debugging uncaught Not_found errors, because the element not found can now be printed straight away without the need for further debugging. The small cost is that one should remember to catch the correct specialised `Foo.Map.Not_found _` exception rather than the standard `Not_found` (which would type-check but not catch the exception). Using `find_opt` should be preferred anyway. Note that the other functions from the module `Map` that raise `Not_found` are not affected ; these functions are `choose`, `min/max_binding`, `find_first/last` which either take a predicate or fail on the empty map, so it wouldn't make sense for them (and we probably don't use them much).
2023-08-15 17:57:52 +03:00
| exception Ident.Map.Not_found _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error (Mark.get id) "No struct named %s found"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove id)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let get_scope ctxt id =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find (Mark.remove id) ctxt.typedefs with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| TScope (id, _) -> id
| TEnum eid ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get id;
Some "Enum defined at", Mark.get (EnumName.get_info eid);
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
]
"Expecting an scope, but found an enum"
| TStruct sid ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get id;
Some "Structure defined at", Mark.get (StructName.get_info sid);
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
]
"Expecting an scope, but found a structure"
Specialise the Map.Not_found exception raised by Map.find ... and add a custom printer Since this is a very common bug, this patch should gain us a lot of time when debugging uncaught Not_found errors, because the element not found can now be printed straight away without the need for further debugging. The small cost is that one should remember to catch the correct specialised `Foo.Map.Not_found _` exception rather than the standard `Not_found` (which would type-check but not catch the exception). Using `find_opt` should be preferred anyway. Note that the other functions from the module `Map` that raise `Not_found` are not affected ; these functions are `choose`, `min/max_binding`, `find_first/last` which either take a predicate or fail on the empty map, so it wouldn't make sense for them (and we probably don't use them much).
2023-08-15 17:57:52 +03:00
| exception Ident.Map.Not_found _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error (Mark.get id) "No scope named %s found"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove id)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let rec module_ctx ctxt path =
match path with
| [] -> ctxt
Fix lookup of built modules in Catala
2023-09-15 15:56:35 +03:00
| modname :: path -> (
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let modname = ModuleName.of_string modname in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
match ModuleName.Map.find_opt modname ctxt.modules with
| None ->
Reformat
2023-09-19 19:21:14 +03:00
Message.raise_spanned_error (ModuleName.pos modname)
"Module \"%a\" not found" ModuleName.format modname
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
| Some ctxt -> module_ctx ctxt path)
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** {1 Declarations pass} *)
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
(** Process a subscope declaration *)
Restored build
2020-11-23 14:20:38 +03:00
let process_subscope_decl
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(scope : ScopeName.t)
Restored build
2020-11-23 14:20:38 +03:00
(ctxt : context)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(decl : Surface.Ast.scope_decl_context_scope) : context =
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
let name, name_pos = decl.scope_decl_context_scope_name in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let (path, subscope), s_pos = decl.scope_decl_context_scope_sub_scope in
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope_ctxt = get_scope_context ctxt scope in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
match Ident.Map.find_opt (Mark.remove subscope) scope_ctxt.var_idmap with
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
| Some use ->
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let info =
match use with
| ScopeVar v -> ScopeVar.get_info v
| SubScope (ssc, _) -> SubScopeName.get_info ssc
in
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
[Some "first use", Mark.get info; Some "second use", s_pos]
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
"Subscope name @{<yellow>\"%s\"@} already used" (Mark.remove subscope)
Fill skeleton for context formation
2020-07-16 15:46:40 +03:00
| None ->
Add scopelang / desugared cases to the shared AST expressions
2022-08-17 18:14:29 +03:00
let sub_scope_uid = SubScopeName.fresh (name, name_pos) in
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
let original_subscope_uid =
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let ctxt = module_ctx ctxt path in
get_scope ctxt subscope
[WIP] Add scheduling to the scopes
2020-08-03 12:03:25 +03:00
in
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
let scope_ctxt =
Restored build
2020-11-23 14:20:38 +03:00
{
scope_ctxt with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
var_idmap =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.add name
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
(SubScope (sub_scope_uid, original_subscope_uid))
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
scope_ctxt.var_idmap;
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
sub_scopes =
ScopeName.Set.add original_subscope_uid scope_ctxt.sub_scopes;
Restored build
2020-11-23 14:20:38 +03:00
}
Formatting: sync with master
2022-05-12 16:10:55 +03:00
in
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
{ ctxt with scopes = ScopeName.Map.add scope scope_ctxt ctxt.scopes }
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let is_type_cond ((typ, _) : Surface.Ast.typ) =
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
match typ with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.Base Surface.Ast.Condition
| Surface.Ast.Func { arg_typ = _; return_typ = Surface.Ast.Condition, _ } ->
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
true
| _ -> false
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process a basic type (all types except function types) *)
Array type is beginning to work
2020-12-30 00:26:10 +03:00
let rec process_base_typ
(ctxt : context)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
((typ, typ_pos) : Surface.Ast.base_typ Mark.pos) : typ =
[WIP] Add function to the language
2020-08-06 16:18:40 +03:00
match typ with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.Condition -> TLit TBool, typ_pos
| Surface.Ast.Data (Surface.Ast.Collection t) ->
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
( TArray
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(process_base_typ ctxt (Surface.Ast.Data (Mark.remove t), Mark.get t)),
Array type is beginning to work
2020-12-30 00:26:10 +03:00
typ_pos )
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.Data (Surface.Ast.Primitive prim) -> (
[WIP] Add function to the language
2020-08-06 16:18:40 +03:00
match prim with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.Integer -> TLit TInt, typ_pos
| Surface.Ast.Decimal -> TLit TRat, typ_pos
| Surface.Ast.Money -> TLit TMoney, typ_pos
| Surface.Ast.Duration -> TLit TDuration, typ_pos
| Surface.Ast.Date -> TLit TDate, typ_pos
| Surface.Ast.Boolean -> TLit TBool, typ_pos
| Surface.Ast.Text -> raise_unsupported_feature "text type" typ_pos
Add support for paths in the parser Using them will lead to "not supported yet" errors soon after, but it's a start to get to handling separate modules. The idea is that `foo` can now also be `Bar.foo`, `Bar.Baz.foo`, `foo.Struc.fld` can be `foo.Bar.Baz.Struc.fld`, etc. The next steps are to enable the lookups to handle this paths, and to provide ways to load the external modules to feed these lookups.
2023-01-04 18:12:36 +03:00
| Surface.Ast.Named ([], (ident, _pos)) -> (
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt ident ctxt.typedefs with
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
| Some (TStruct s_uid) -> TStruct s_uid, typ_pos
| Some (TEnum e_uid) -> TEnum e_uid, typ_pos
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
| Some (TScope (_, scope_str)) ->
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
TStruct scope_str.out_struct_name, typ_pos
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| None ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error typ_pos
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
"Unknown type @{<yellow>\"%s\"@}, not a struct or enum previously \
declared"
Add support for paths in the parser Using them will lead to "not supported yet" errors soon after, but it's a start to get to handling separate modules. The idea is that `foo` can now also be `Bar.foo`, `Bar.Baz.foo`, `foo.Struc.fld` can be `foo.Bar.Baz.Struc.fld`, etc. The next steps are to enable the lookups to handle this paths, and to provide ways to load the external modules to feed these lookups.
2023-01-04 18:12:36 +03:00
ident)
Fix lookup of built modules in Catala
2023-09-15 15:56:35 +03:00
| Surface.Ast.Named (modul :: path, id) -> (
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let modul = ModuleName.of_string modul in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
match ModuleName.Map.find_opt modul ctxt.modules with
| None ->
Fix lookup of built modules in Catala
2023-09-15 15:56:35 +03:00
Message.raise_spanned_error (ModuleName.pos modul)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
"This refers to module %a, which was not found" ModuleName.format
modul
| Some mod_ctxt ->
process_base_typ mod_ctxt
Surface.Ast.(Data (Primitive (Named (path, id))), typ_pos)))
[WIP] Add function to the language
2020-08-06 16:18:40 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process a type (function or not) *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let process_type (ctxt : context) ((naked_typ, typ_pos) : Surface.Ast.typ) : typ
=
Same treatment for `typ` and `marked_typ`
2022-08-25 18:29:00 +03:00
match naked_typ with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.Base base_typ -> process_base_typ ctxt (base_typ, typ_pos)
| Surface.Ast.Func { arg_typ; return_typ } ->
Syntax change: require declaration of function argument names
2023-02-24 12:02:12 +03:00
let targs = List.map (fun (_, t) -> process_base_typ ctxt t) arg_typ in
TArrow (targs, process_base_typ ctxt return_typ), typ_pos
[WIP] Add function to the language
2020-08-06 16:18:40 +03:00
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
(** Process data declaration *)
Restored build
2020-11-23 14:20:38 +03:00
let process_data_decl
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(scope : ScopeName.t)
Restored build
2020-11-23 14:20:38 +03:00
(ctxt : context)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(decl : Surface.Ast.scope_decl_context_data) : context =
Fill skeleton for context formation
2020-07-16 15:46:40 +03:00
(* First check the type of the context data *)
Introduce intermediate typ structure with named structs and enums
2020-12-04 20:48:16 +03:00
let data_typ = process_type ctxt decl.scope_decl_context_item_typ in
Various fixes, now passing first French tests
2020-12-31 02:28:26 +03:00
let is_cond = is_type_cond decl.scope_decl_context_item_typ in
Add position lookup for uids
2020-08-04 13:44:56 +03:00
let name, pos = decl.scope_decl_context_item_name in
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope_ctxt = get_scope_context ctxt scope in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt name scope_ctxt.var_idmap with
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
| Some use ->
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let info =
match use with
| ScopeVar v -> ScopeVar.get_info v
| SubScope (ssc, _) -> SubScopeName.get_info ssc
in
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
[Some "First use:", Mark.get info; Some "Second use:", pos]
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
"Variable name @{<yellow>\"%s\"@} already used" name
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
| None ->
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
let uid = ScopeVar.fresh (name, pos) in
Slowly connecting dots, missing a translation
2020-11-25 12:49:53 +03:00
let scope_ctxt =
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
{
Restored build
2020-11-23 14:20:38 +03:00
scope_ctxt with
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
var_idmap = Ident.Map.add name (ScopeVar uid) scope_ctxt.var_idmap;
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
}
Formatting: sync with master
2022-05-12 16:10:55 +03:00
in
Name resolution
2022-02-28 17:40:19 +03:00
let states_idmap, states_list =
List.fold_right
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(fun state_id ((states_idmap : StateName.t Ident.Map.t), states_list) ->
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
let state_id_name = Mark.remove state_id in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
if Ident.Map.mem state_id_name states_idmap then
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error_full
Error message when two same states
2023-04-27 16:37:11 +03:00
[
( Some
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
(fun ppf ->
Format.fprintf ppf
"First instance of state @{<yellow>\"%s\"@}:"
state_id_name),
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Mark.get state_id );
Error message when two same states
2023-04-27 16:37:11 +03:00
( Some
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
(fun ppf ->
Format.fprintf ppf
"Second instance of state @{<yellow>\"%s\"@}:"
state_id_name),
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Mark.get
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find state_id_name states_idmap
Error message when two same states
2023-04-27 16:37:11 +03:00
|> StateName.get_info) );
]
"There are two states with the same name for the same variable: \
this is ambiguous. Please change the name of either states.";
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
let state_uid = StateName.fresh state_id in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
( Ident.Map.add state_id_name state_uid states_idmap,
Name resolution
2022-02-28 17:40:19 +03:00
state_uid :: states_list ))
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
decl.scope_decl_context_item_states (Ident.Map.empty, [])
Formatting: sync with master
2022-05-12 16:10:55 +03:00
in
Enforce consistency of function arguments naming
2023-02-27 11:50:42 +03:00
let var_sig_parameters =
Fix multi-argument scopedefs, improve error message positions This adds a few positions to the parser, and tweaks some others, vastly improving the reporting of some errors (inconsistent functions definitions, but also exceptions cycles, etc.)
2023-02-28 16:40:05 +03:00
Option.map
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.map (List.map (fun (lbl, typ) -> lbl, process_type ctxt typ)))
Enforce consistency of function arguments naming
2023-02-27 11:50:42 +03:00
decl.scope_decl_context_item_parameters
in
Formatting: sync with master
2022-05-12 16:10:55 +03:00
{
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
ctxt with
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
scopes = ScopeName.Map.add scope scope_ctxt ctxt.scopes;
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
var_typs =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
ScopeVar.Map.add uid
Formatting: sync with master
2022-05-12 16:10:55 +03:00
{
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
var_sig_typ = data_typ;
var_sig_is_condition = is_cond;
Enforce consistency of function arguments naming
2023-02-27 11:50:42 +03:00
var_sig_parameters;
Finer control over input IO (distinction only_input/reentrant) [skip ci]
2022-02-07 12:30:36 +03:00
var_sig_io = decl.scope_decl_context_item_attribute;
Name resolution
2022-02-28 17:40:19 +03:00
var_sig_states_idmap = states_idmap;
var_sig_states_list = states_list;
Formatting: sync with master
2022-05-12 16:10:55 +03:00
}
First test passing, awaiting rest of features (subscopes, etc.)
2022-02-05 02:04:19 +03:00
ctxt.var_typs;
Formatting: sync with master
2022-05-12 16:10:55 +03:00
}
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process a struct declaration *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let process_struct_decl (ctxt : context) (sdecl : Surface.Ast.struct_decl) :
context =
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let s_uid = get_struct ctxt sdecl.struct_decl_name in
if sdecl.struct_decl_fields = [] then
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.get sdecl.struct_decl_name)
Nice error messages for empty structs and enums
2022-03-28 15:43:38 +03:00
"The struct %s does not have any fields; give it some for Catala to be \
able to accept it."
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove sdecl.struct_decl_name);
Implemented name resolution
2020-12-04 20:02:49 +03:00
List.fold_left
(fun ctxt (fdecl, _) ->
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
let f_uid = StructField.fresh fdecl.Surface.Ast.struct_decl_field_name in
Implemented name resolution
2020-12-04 20:02:49 +03:00
let ctxt =
{
ctxt with
field_idmap =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.update
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove fdecl.Surface.Ast.struct_decl_field_name)
Implemented name resolution
2020-12-04 20:02:49 +03:00
(fun uids ->
match uids with
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
| None -> Some (StructName.Map.singleton s_uid f_uid)
| Some uids -> Some (StructName.Map.add s_uid f_uid uids))
Implemented name resolution
2020-12-04 20:02:49 +03:00
ctxt.field_idmap;
}
in
{
ctxt with
structs =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
StructName.Map.update s_uid
Implemented name resolution
2020-12-04 20:02:49 +03:00
(fun fields ->
match fields with
| None ->
Some
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
(StructField.Map.singleton f_uid
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(process_type ctxt fdecl.Surface.Ast.struct_decl_field_typ))
Implemented name resolution
2020-12-04 20:02:49 +03:00
| Some fields ->
Some
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
(StructField.Map.add f_uid
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(process_type ctxt fdecl.Surface.Ast.struct_decl_field_typ)
Implemented name resolution
2020-12-04 20:02:49 +03:00
fields))
ctxt.structs;
})
ctxt sdecl.struct_decl_fields
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process an enum declaration *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let process_enum_decl (ctxt : context) (edecl : Surface.Ast.enum_decl) : context
=
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let e_uid = get_enum ctxt edecl.enum_decl_name in
Nice error messages for empty structs and enums
2022-03-28 15:43:38 +03:00
if List.length edecl.enum_decl_cases = 0 then
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.get edecl.enum_decl_name)
Nice error messages for empty structs and enums
2022-03-28 15:43:38 +03:00
"The enum %s does not have any cases; give it some for Catala to be able \
to accept it."
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove edecl.enum_decl_name);
Implemented name resolution
2020-12-04 20:02:49 +03:00
List.fold_left
(fun ctxt (cdecl, cdecl_pos) ->
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let c_uid = EnumConstructor.fresh cdecl.Surface.Ast.enum_decl_case_name in
Implemented name resolution
2020-12-04 20:02:49 +03:00
let ctxt =
{
ctxt with
constructor_idmap =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.update
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove cdecl.Surface.Ast.enum_decl_case_name)
Implemented name resolution
2020-12-04 20:02:49 +03:00
(fun uids ->
match uids with
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
| None -> Some (EnumName.Map.singleton e_uid c_uid)
| Some uids -> Some (EnumName.Map.add e_uid c_uid uids))
Implemented name resolution
2020-12-04 20:02:49 +03:00
ctxt.constructor_idmap;
}
in
{
ctxt with
enums =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
EnumName.Map.update e_uid
Implemented name resolution
2020-12-04 20:02:49 +03:00
(fun cases ->
let typ =
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
match cdecl.Surface.Ast.enum_decl_case_typ with
Used `shared_ast` for scopelang expressions
2022-08-25 13:09:51 +03:00
| None -> TLit TUnit, cdecl_pos
Introduce intermediate typ structure with named structs and enums
2020-12-04 20:48:16 +03:00
| Some typ -> process_type ctxt typ
Implemented name resolution
2020-12-04 20:02:49 +03:00
in
match cases with
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
| None -> Some (EnumConstructor.Map.singleton c_uid typ)
| Some fields -> Some (EnumConstructor.Map.add c_uid typ fields))
Implemented name resolution
2020-12-04 20:02:49 +03:00
ctxt.enums;
})
ctxt edecl.enum_decl_cases
Fixes related to environments and lookups
2023-08-31 17:54:45 +03:00
let process_topdef ctxt def =
let uid =
Ident.Map.find (Mark.remove def.Surface.Ast.topdef_name) ctxt.topdefs
in
{
ctxt with
topdef_types =
TopdefName.Map.add uid
(process_type ctxt def.Surface.Ast.topdef_type)
ctxt.topdef_types;
}
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** Process an item declaration *)
let process_item_decl
(scope : ScopeName.t)
(ctxt : context)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(decl : Surface.Ast.scope_decl_context_item) : context =
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
match decl with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.ContextData data_decl -> process_data_decl scope ctxt data_decl
| Surface.Ast.ContextScope sub_decl ->
process_subscope_decl scope ctxt sub_decl
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(** Process a scope declaration *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let process_scope_decl (ctxt : context) (decl : Surface.Ast.scope_decl) :
context =
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let scope_uid = get_scope ctxt decl.scope_decl_name in
let ctxt =
List.fold_left
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(fun ctxt item -> process_item_decl scope_uid ctxt (Mark.remove item))
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
ctxt decl.scope_decl_context
in
(* Add an implicit struct def for the scope output type *)
let output_fields =
List.fold_right
(fun item acc ->
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
match Mark.remove item with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.ContextData
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
({
scope_decl_context_item_attribute =
{ scope_decl_context_io_output = true, _; _ };
_;
} as data) ->
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Mark.add (Mark.get item)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
{
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
Surface.Ast.struct_decl_field_name =
data.scope_decl_context_item_name;
Surface.Ast.struct_decl_field_typ =
data.scope_decl_context_item_typ;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
}
:: acc
| _ -> acc)
decl.scope_decl_context []
in
if output_fields = [] then
(* we allow scopes without output variables, and still define their (empty)
output struct for convenience *)
{
ctxt with
structs =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
StructName.Map.add
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(get_struct ctxt decl.scope_decl_name)
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
StructField.Map.empty ctxt.structs;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
}
else
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
let ctxt =
process_struct_decl ctxt
{
struct_decl_name = decl.scope_decl_name;
struct_decl_fields = output_fields;
}
in
let out_struct_fields =
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let sco = get_scope_context ctxt scope_uid in
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
let str = get_struct ctxt decl.scope_decl_name in
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.fold
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
(fun id var svmap ->
match var with
| SubScope _ -> svmap
| ScopeVar v -> (
try
let field =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
StructName.Map.find str (Ident.Map.find id ctxt.field_idmap)
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
in
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
ScopeVar.Map.add v field svmap
Specialise the Map.Not_found exception raised by Map.find ... and add a custom printer Since this is a very common bug, this patch should gain us a lot of time when debugging uncaught Not_found errors, because the element not found can now be printed straight away without the need for further debugging. The small cost is that one should remember to catch the correct specialised `Foo.Map.Not_found _` exception rather than the standard `Not_found` (which would type-check but not catch the exception). Using `find_opt` should be preferred anyway. Note that the other functions from the module `Map` that raise `Not_found` are not affected ; these functions are `choose`, `min/max_binding`, `find_first/last` which either take a predicate or fail on the empty map, so it wouldn't make sense for them (and we probably don't use them much).
2023-08-15 17:57:52 +03:00
with StructName.Map.Not_found _ | Ident.Map.Not_found _ -> svmap))
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
sco.var_idmap ScopeVar.Map.empty
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
in
let typedefs =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.update
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove decl.scope_decl_name)
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
(function
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
| Some (TScope (scope, { in_struct_name; out_struct_name; _ })) ->
Some
(TScope
(scope, { in_struct_name; out_struct_name; out_struct_fields }))
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
| _ -> assert false)
ctxt.typedefs
in
{ ctxt with typedefs }
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
let typedef_info = function
| TStruct t -> StructName.get_info t
| TEnum t -> EnumName.get_info t
| TScope (s, _) -> ScopeName.get_info s
Fix #47
2021-03-12 19:07:25 +03:00
(** Process the names of all declaration items *)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
let process_name_item (ctxt : context) (item : Surface.Ast.code_item Mark.pos) :
context =
Fixes #107
2021-04-29 18:46:56 +03:00
let raise_already_defined_error (use : Uid.MarkedString.info) name pos msg =
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error_full
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
[
( Some (fun ppf -> Format.pp_print_string ppf "First definition:"),
Mark.get use );
Some (fun ppf -> Format.pp_print_string ppf "Second definition:"), pos;
]
"%s name @{<yellow>\"%s\"@} already defined" msg name
Fix #47
2021-03-12 19:07:25 +03:00
in
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
match Mark.remove item with
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
| ScopeDecl decl ->
Fix #47
2021-03-12 19:07:25 +03:00
let name, pos = decl.scope_decl_name in
(* Checks if the name is already used *)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
Option.iter
(fun use ->
raise_already_defined_error (typedef_info use) name pos "scope")
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find_opt name ctxt.typedefs);
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let scope_uid = ScopeName.fresh ctxt.path (name, pos) in
let in_struct_name = StructName.fresh ctxt.path (name ^ "_in", pos) in
let out_struct_name = StructName.fresh ctxt.path (name, pos) in
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
{
ctxt with
typedefs =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.add name
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
(TScope
( scope_uid,
{
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
in_struct_name;
out_struct_name;
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
out_struct_fields = ScopeVar.Map.empty;
AST refactoring Many changes got bundled in here and would be too tedious to separate. Closes #330 See changes in `shared_ast/definitions.ml` to check the main point. - the biggest change is a modification of the struct and enum types in expressions: they are now stored as `Map`s throughout passes, and no longer converted to indexed lists after scopelang. Their accessors are also changed, and tuples only exist in Lcalc (they're used for closure conversion). This implied adding some more information in the contexts, to keep the mapping between struct fields and scope output variables. It should also be much more robust (no longer relying on assumptions upon different orderings). - another very pervasive change is more cosmetic: the rewrite of the main AST to use inline records, labelling individual subfields. - moved the checks for correct definitions and accesses of structures from `Scope_to_dcalc` to `Typing` - defining some new shallow iterators in module `Shared_ast.Expr`, and factorising a few same-pass rewriting functions accordingly (closure conversion, optimisations, etc.) - some smaller style improvements (ensuring we use the proper compare/equal functions instead of `=` in a few `when` closes, for example)
2022-11-17 19:13:35 +03:00
} ))
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
ctxt.typedefs;
scopes =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
ScopeName.Map.add scope_uid
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
{
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
var_idmap = Ident.Map.empty;
Refactoring changes after @altgr's suggestions
2023-04-18 11:31:44 +03:00
scope_defs_contexts = Ast.ScopeDef.Map.empty;
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
sub_scopes = ScopeName.Set.empty;
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
}
ctxt.scopes;
}
| StructDecl sdecl ->
Fix #47
2021-03-12 19:07:25 +03:00
let name, pos = sdecl.struct_decl_name in
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
Option.iter
(fun use ->
raise_already_defined_error (typedef_info use) name pos "struct")
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find_opt name ctxt.typedefs);
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let s_uid = StructName.fresh ctxt.path sdecl.struct_decl_name in
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
{
ctxt with
typedefs =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.add
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove sdecl.struct_decl_name)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(TStruct s_uid) ctxt.typedefs;
}
| EnumDecl edecl ->
Fix #47
2021-03-12 19:07:25 +03:00
let name, pos = edecl.enum_decl_name in
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
Option.iter
(fun use ->
raise_already_defined_error (typedef_info use) name pos "enum")
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find_opt name ctxt.typedefs);
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let e_uid = EnumName.fresh ctxt.path edecl.enum_decl_name in
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
{
ctxt with
typedefs =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.add
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove edecl.enum_decl_name)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
(TEnum e_uid) ctxt.typedefs;
}
Fix #47
2021-03-12 19:07:25 +03:00
| ScopeUse _ -> ctxt
Add top-level definitions Only handled until before scalc at the moment.
2023-01-23 14:19:36 +03:00
| Topdef def ->
let name, pos = def.topdef_name in
Option.iter
(fun use ->
raise_already_defined_error (TopdefName.get_info use) name pos
"toplevel definition")
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find_opt name ctxt.topdefs);
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let uid = TopdefName.fresh ctxt.path def.topdef_name in
Fixes related to environments and lookups
2023-08-31 17:54:45 +03:00
{ ctxt with topdefs = Ident.Map.add name uid ctxt.topdefs }
Fix #47
2021-03-12 19:07:25 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process a code item that is a declaration *)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
let process_decl_item (ctxt : context) (item : Surface.Ast.code_item Mark.pos) :
context =
match Mark.remove item with
Implemented name resolution
2020-12-04 20:02:49 +03:00
| ScopeDecl decl -> process_scope_decl ctxt decl
| StructDecl sdecl -> process_struct_decl ctxt sdecl
| EnumDecl edecl -> process_enum_decl ctxt edecl
| ScopeUse _ -> ctxt
Fixes related to environments and lookups
2023-08-31 17:54:45 +03:00
| Topdef def -> process_topdef ctxt def
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
(** Process a code block *)
Slowly connecting dots, missing a translation
2020-11-25 12:49:53 +03:00
let process_code_block
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(process_item : context -> Surface.Ast.code_item Mark.pos -> context)
Slowly connecting dots, missing a translation
2020-11-25 12:49:53 +03:00
(ctxt : context)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(block : Surface.Ast.code_block) : context =
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
List.fold_left (fun ctxt decl -> process_item ctxt decl) ctxt block
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Process a law structure, only considering the code blocks *)
Slowly connecting dots, missing a translation
2020-11-25 12:49:53 +03:00
let rec process_law_structure
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(process_item : context -> Surface.Ast.code_item Mark.pos -> context)
Slowly connecting dots, missing a translation
2020-11-25 12:49:53 +03:00
(ctxt : context)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(s : Surface.Ast.law_structure) : context =
Literate programming AST now tree-shaped
2020-10-04 02:25:37 +03:00
match s with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.LawHeading (_, children) ->
Literate programming AST now tree-shaped
2020-10-04 02:25:37 +03:00
List.fold_left
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(fun ctxt child -> process_law_structure process_item ctxt child)
Literate programming AST now tree-shaped
2020-10-04 02:25:37 +03:00
ctxt children
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.CodeBlock (block, _, _) ->
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
process_code_block process_item ctxt block
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Surface.Ast.LawInclude _ | Surface.Ast.LawText _ -> ctxt
support for parsing Module directives
2023-09-05 16:00:55 +03:00
| Surface.Ast.ModuleDef _ | Surface.Ast.ModuleUse _ -> ctxt
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
(** {1 Scope uses pass} *)
Added desugared AST, necessary to distinguish Desugared.ScopeVar from Scopelang.ScopeVar [skip ci]
2022-02-28 19:19:06 +03:00
let get_def_key
Add support for paths in the parser Using them will lead to "not supported yet" errors soon after, but it's a start to get to handling separate modules. The idea is that `foo` can now also be `Bar.foo`, `Bar.Baz.foo`, `foo.Struc.fld` can be `foo.Bar.Baz.Struc.fld`, etc. The next steps are to enable the lookups to handle this paths, and to provide ways to load the external modules to feed these lookups.
2023-01-04 18:12:36 +03:00
(name : Surface.Ast.scope_var)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(state : Surface.Ast.lident Mark.pos option)
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(scope_uid : ScopeName.t)
Added desugared AST, necessary to distinguish Desugared.ScopeVar from Scopelang.ScopeVar [skip ci]
2022-02-28 19:19:06 +03:00
(ctxt : context)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(pos : Pos.t) : Ast.ScopeDef.t =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
let scope_ctxt = ScopeName.Map.find scope_uid ctxt.scopes in
Improve unlabeled exceptions: Default definitions and unlabeled exceptions in the same scope can now be defined in different code blocks
2021-01-22 07:47:48 +03:00
match name with
| [x] ->
let x_uid = get_var_uid scope_uid ctxt x in
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
let var_sig = ScopeVar.Map.find x_uid ctxt.var_typs in
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
Ast.ScopeDef.Var
Added desugared AST, necessary to distinguish Desugared.ScopeVar from Scopelang.ScopeVar [skip ci]
2022-02-28 19:19:06 +03:00
( x_uid,
More negative tests
2022-03-07 13:55:26 +03:00
match state with
| Some state -> (
try
Some
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
(Ident.Map.find (Mark.remove state) var_sig.var_sig_states_idmap)
Specialise the Map.Not_found exception raised by Map.find ... and add a custom printer Since this is a very common bug, this patch should gain us a lot of time when debugging uncaught Not_found errors, because the element not found can now be printed straight away without the need for further debugging. The small cost is that one should remember to catch the correct specialised `Foo.Map.Not_found _` exception rather than the standard `Not_found` (which would type-check but not catch the exception). Using `find_opt` should be preferred anyway. Note that the other functions from the module `Map` that raise `Not_found` are not affected ; these functions are `choose`, `min/max_binding`, `find_first/last` which either take a predicate or fail on the empty map, so it wouldn't make sense for them (and we probably don't use them much).
2023-08-15 17:57:52 +03:00
with Ident.Map.Not_found _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
Simple tests
2022-03-06 19:13:40 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get state;
Some "Variable declaration:", Mark.get (ScopeVar.get_info x_uid);
Use format strings directly in debug/error/log functions This avoids many intermediate calls to e.g. `Format.asprintf`; should result in some cases in "more correct" use of `Format`¹, avoid the computation of unused debug strings, and make the code more readable. ¹ for `Format` to work as expected, all intermediate calls need to go through it. Some cases of formatting to an intermediate string then printing through Format again are still present, but this makes the situation better.
2022-03-08 15:04:27 +03:00
]
"This identifier is not a state declared for variable %a."
Add some helper functions in a wrapper `Map` module and use them throughout. No more `List.map fst (Map.bindings m)` ! Also adds some facilities for direct formatting without going through a list.
2023-07-12 12:48:46 +03:00
ScopeVar.format x_uid)
More negative tests
2022-03-07 13:55:26 +03:00
| None ->
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
if not (Ident.Map.is_empty var_sig.var_sig_states_idmap) then
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_multispanned_error
More negative tests
2022-03-07 13:55:26 +03:00
[
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
None, Mark.get x;
Some "Variable declaration:", Mark.get (ScopeVar.get_info x_uid);
More negative tests
2022-03-07 13:55:26 +03:00
]
Use format strings directly in debug/error/log functions This avoids many intermediate calls to e.g. `Format.asprintf`; should result in some cases in "more correct" use of `Format`¹, avoid the computation of unused debug strings, and make the code more readable. ¹ for `Format` to work as expected, all intermediate calls need to go through it. Some cases of formatting to an intermediate string then printing through Format again are still present, but this makes the situation better.
2022-03-08 15:04:27 +03:00
"This definition does not indicate which state has to be \
considered for variable %a."
Add some helper functions in a wrapper `Map` module and use them throughout. No more `List.map fst (Map.bindings m)` ! Also adds some facilities for direct formatting without going through a list.
2023-07-12 12:48:46 +03:00
ScopeVar.format x_uid
More negative tests
2022-03-07 13:55:26 +03:00
else None )
Improve unlabeled exceptions: Default definitions and unlabeled exceptions in the same scope can now be defined in different code blocks
2021-01-22 07:47:48 +03:00
| [y; x] ->
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let (subscope_uid, subscope_real_uid) : SubScopeName.t * ScopeName.t =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
match Ident.Map.find_opt (Mark.remove y) scope_ctxt.var_idmap with
Fix error handling of invalid subscope variable assignments
2022-10-26 12:09:15 +03:00
| Some (SubScope (v, u)) -> v, u
| Some _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error pos
Callable scopes: fixes following review
2022-11-03 17:18:51 +03:00
"Invalid access to input variable, %a is not a subscope"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Print.lit_style (Mark.remove y)
Fix error handling of invalid subscope variable assignments
2022-10-26 12:09:15 +03:00
| None ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error pos "No definition found for subscope %a"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Print.lit_style (Mark.remove y)
Improve unlabeled exceptions: Default definitions and unlabeled exceptions in the same scope can now be defined in different code blocks
2021-01-22 07:47:48 +03:00
in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let x_uid = get_var_uid subscope_real_uid ctxt x in
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
Ast.ScopeDef.SubScopeVar (subscope_uid, x_uid, pos)
Better error message
2022-06-01 12:13:14 +03:00
| _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error pos
Better error message
2022-06-01 12:13:14 +03:00
"This line is defining a quantity that is neither a scope variable nor a \
subscope variable. In particular, it is not possible to define struct \
fields individually in Catala."
Improve unlabeled exceptions: Default definitions and unlabeled exceptions in the same scope can now be defined in different code blocks
2021-01-22 07:47:48 +03:00
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
let update_def_key_ctx
(d : Surface.Ast.definition)
(def_key_ctx : scope_def_context) : scope_def_context =
(* First, we update the def key context with information about the
definition's label*)
let def_key_ctx =
match d.Surface.Ast.definition_label with
| None -> def_key_ctx
| Some label ->
let new_label_idmap =
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.update (Mark.remove label)
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
(fun existing_label ->
match existing_label with
| Some existing_label -> Some existing_label
| None -> Some (LabelName.fresh label))
def_key_ctx.label_idmap
in
{ def_key_ctx with label_idmap = new_label_idmap }
in
(* And second, we update the map of default rulenames for unlabeled
exceptions *)
match d.Surface.Ast.definition_exception_to with
(* If this definition is an exception, it cannot be a default definition *)
| UnlabeledException | ExceptionToLabel _ -> def_key_ctx
(* If it is not an exception, we need to distinguish between several cases *)
| NotAnException -> (
match def_key_ctx.default_exception_rulename with
(* There was already a default definition for this key. If we need it, it is
ambiguous *)
| Some old ->
{
def_key_ctx with
default_exception_rulename =
Some
(Ambiguous
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
([Mark.get d.definition_name]
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
@
match old with Ambiguous old -> old | Unique (_, pos) -> [pos]));
}
(* No definition has been set yet for this key *)
| None -> (
match d.Surface.Ast.definition_label with
(* This default definition has a label. This is not allowed for unlabeled
exceptions *)
| Some _ ->
{
def_key_ctx with
default_exception_rulename =
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Some (Ambiguous [Mark.get d.definition_name]);
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
}
(* This is a possible default definition for this key. We create and store
a fresh rulename *)
| None ->
{
def_key_ctx with
default_exception_rulename =
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
Some (Unique (d.definition_id, Mark.get d.definition_name));
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
}))
let empty_def_key_ctx =
{
(* Here, this is the first time we encounter a definition for this
definition key *)
default_exception_rulename = None;
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
label_idmap = Ident.Map.empty;
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
}
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
let process_definition
(ctxt : context)
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(s_name : ScopeName.t)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
(d : Surface.Ast.definition) : context =
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
(* We update the definition context inside the big context *)
{
ctxt with
scopes =
Rename all Map/Set calls accordingly This is just a bunch of `sed` calls: ```shell sed -i 's/ScopeSet/ScopeName.Set/g' compiler/**/*.ml* sed -i 's/ScopeMap/ScopeName.Map/g' compiler/**/*.ml* sed -i 's/StructMap/StructName.Map/g' compiler/**/*.ml* sed -i 's/StructSet/StructName.Set/g' compiler/**/*.ml* sed -i 's/EnumMap/EnumName.Map/g' compiler/**/*.ml* sed -i 's/EnumSet/EnumName.Set/g' compiler/**/*.ml* sed -i 's/StructFieldName/StructField/g' compiler/**/*.ml* sed -i 's/StructFieldMap/StructField.Map/g' compiler/**/*.ml* sed -i 's/StructFieldSet/StructField.Set/g' compiler/**/*.ml* sed -i 's/EnumConstructorMap/EnumConstructor.Map/g' compiler/**/*.ml* sed -i 's/EnumConstructorSet/EnumConstructor.Set/g' compiler/**/*.ml* sed -i 's/RuleMap/RuleName.Map/g' compiler/**/*.ml* sed -i 's/RuleSet/RuleName.Set/g' compiler/**/*.ml* sed -i 's/LabelMap/LabelName.Map/g' compiler/**/*.ml* sed -i 's/LabelSet/LabelName.Set/g' compiler/**/*.ml* sed -i 's/ScopeVarMap/ScopeVar.Map/g' compiler/**/*.ml* sed -i 's/ScopeVarSet/ScopeVar.Set/g' compiler/**/*.ml* sed -i 's/SubScopeNameMap/SubScopeName.Map/g' compiler/**/*.ml* sed -i 's/SubScopeNameSet/SubScopeName.Set/g' compiler/**/*.ml* ``` ... and reformat
2022-11-21 12:12:45 +03:00
ScopeName.Map.update s_name
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
(fun (s_ctxt : scope_context option) ->
let def_key =
Added desugared AST, necessary to distinguish Desugared.ScopeVar from Scopelang.ScopeVar [skip ci]
2022-02-28 19:19:06 +03:00
get_def_key
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove d.definition_name)
Added desugared AST, necessary to distinguish Desugared.ScopeVar from Scopelang.ScopeVar [skip ci]
2022-02-28 19:19:06 +03:00
d.definition_state s_name ctxt
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.get d.definition_name)
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
in
match s_ctxt with
| None -> assert false (* should not happen *)
| Some s_ctxt ->
Some
{
s_ctxt with
scope_defs_contexts =
Refactoring changes after @altgr's suggestions
2023-04-18 11:31:44 +03:00
Ast.ScopeDef.Map.update def_key
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
(fun def_key_ctx ->
Name resolution: small reformatting
2022-11-18 18:12:14 +03:00
Some
(update_def_key_ctx d
(Option.value ~default:empty_def_key_ctx def_key_ctx)))
Changed label scoping from scope to scope definition key [skip ci]
2022-01-03 20:39:59 +03:00
s_ctxt.scope_defs_contexts;
})
ctxt.scopes;
}
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
let process_scope_use_item
Leverage the shared AST: big cleanup (part I)
2022-08-12 23:42:39 +03:00
(s_name : ScopeName.t)
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
(ctxt : context)
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(sitem : Surface.Ast.scope_use_item Mark.pos) : context =
match Mark.remove sitem with
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
| Rule r -> process_definition ctxt s_name (Surface.Ast.rule_to_def r)
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
| Definition d -> process_definition ctxt s_name d
| _ -> ctxt
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let process_scope_use (ctxt : context) (suse : Surface.Ast.scope_use) : context
=
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
let s_name =
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
match
Rename 'IdentName' to 'Ident'
2023-04-18 15:39:38 +03:00
Ident.Map.find_opt
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove suse.Surface.Ast.scope_use_name)
Make scopes directly callable Quite a few changes are included here, some of which have some extra implications visible in the language: - adds the `Scope of { -- input_v: value; ... }` construct in the language - handle it down the pipeline: * `ScopeCall` in the surface AST * `EScopeCall` in desugared and scopelang * expressions are now traversed to detect dependencies between scopes * transformed into a normal function call in dcalc - defining a scope now implicitely defines a structure with the same name, with the output variables of the scope defined as fields. This allows us to type the return value from a scope call and access its fields easily. * the implications are mostly in surface/name_resolution.ml code-wise * the `Scope_out` struct that was defined in scope_to_dcalc is no longer needed/used and the fields are no longer renamed (changes some outputs; the explicit suffix for variables with multiple states is ignored as well) * one benefit is that disambiguation works just like for structures when there are conflicts on field names * however, it's now a conflict if a scope and a structure have the same name (side-note: issues with conflicting enum / struct names or scope variables / subscope names were silent and are now properly reported) - you can consequently use scope names as types for variables as well. Writing literals is not allowed though, they can only be obtained by calling the scope. Remaining TODOs: - context variables are not handled properly at the moment - error handling on invalid calls - tests show a small error message regression; lots of examples will need tweaking to avoid scope/struct name or struct fields / output variable conflicts - add a `->` syntax to make struct field access distinct from scope output var access, enforced with typing. This is expected to reduce confusion of users and add a little typing precision. - document the new syntax & implications (tutorial, cheat-sheet) - a consequence of the changes is that subscope variables also can now be typed. A possible future evolution / simplification would be to rewrite subscopes as explicit scope calls early in the pipeline. That could also allow to manipulate them as expressions (bind them in let-ins, return them...)
2022-10-21 16:47:17 +03:00
ctxt.typedefs
with
| Some (TScope (sn, _)) -> sn
| _ ->
Messages renamed to Message (lighter syntax)
2023-06-13 12:27:45 +03:00
Message.raise_spanned_error
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.get suse.Surface.Ast.scope_use_name)
Use ocolor instead of ANSITerminal
2023-06-07 19:10:50 +03:00
"@{<yellow>\"%s\"@}: this scope has not been declared anywhere, is it \
a typo?"
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
(Mark.remove suse.Surface.Ast.scope_use_name)
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
in
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
List.fold_left
(process_scope_use_item s_name)
ctxt suse.Surface.Ast.scope_use_items
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
Rework and normalise the `Marked` interface The module is renamed to `Mark`, and functions renamed to avoid redundancy: `Marked.mark` is now `Mark.add` `Marked.unmark` is now `Mark.remove` `Marked.map_under_mark` is now simply `Mark.map` etc. `Marked.same_mark_as` is replaced by `Mark.copy`, but with the arguments swapped (which seemed more convenient throughout) Since a type `Mark.t` would indicate a mark, and to avoid confusion, the type `Marked.t` is renamed to `Mark.ed` as a shorthand for `Mark.marked` ; this part can easily be removed if that's too much quirkiness.
2023-05-17 16:44:57 +03:00
let process_use_item (ctxt : context) (item : Surface.Ast.code_item Mark.pos) :
context =
match Mark.remove item with
Add top-level definitions Only handled until before scalc at the moment.
2023-01-23 14:19:36 +03:00
| ScopeDecl _ | StructDecl _ | EnumDecl _ | Topdef _ -> ctxt
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
| ScopeUse suse -> process_scope_use ctxt suse
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** {1 API} *)
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let empty_ctxt =
{
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
path = [];
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
typedefs = Ident.Map.empty;
scopes = ScopeName.Map.empty;
topdefs = Ident.Map.empty;
topdef_types = TopdefName.Map.empty;
var_typs = ScopeVar.Map.empty;
structs = StructName.Map.empty;
field_idmap = Ident.Map.empty;
enums = EnumName.Map.empty;
constructor_idmap = Ident.Map.empty;
modules = ModuleName.Map.empty;
}
let import_module modules (name, intf) =
Fix lookup of built modules in Catala
2023-09-15 15:56:35 +03:00
let mname = ModuleName.of_string name in
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
let ctxt = { empty_ctxt with modules; path = [mname] } in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let ctxt = List.fold_left process_name_item ctxt intf in
let ctxt = List.fold_left process_decl_item ctxt intf in
let ctxt = { ctxt with modules = empty_ctxt.modules } in
(* No submodules at the moment, a module may use the ones loaded before it,
but doesn't reexport them *)
Simplification: store paths in Uids rather than scattered in structures The context is still hierarchical for defs though, so one needs to retrieve the path to lookup in the correct context for info. Exceptions are enums and struct defs, which are re-exposed at toplevel.
2023-08-30 18:49:29 +03:00
ModuleName.Map.add mname ctxt modules
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
Added ocamldoc, doc'ed Surface
2020-12-14 17:23:04 +03:00
(** Derive the context from metadata, in one pass over the declarations *)
Uniform naming of conversion modules across compilation passes
2022-11-07 15:50:28 +03:00
let form_context (prgm : Surface.Ast.program) : context =
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let modules =
List.fold_left import_module ModuleName.Map.empty prgm.program_modules
Add skeleton for context formation
2020-07-16 13:04:23 +03:00
in
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
let ctxt = { empty_ctxt with modules } in
Gather the maps for subscope vars to the top level (they use UIDs so this doesn't jeopardize proper name resolution ; and it allows resolution of subscope calls without further code modifications)
2023-08-16 00:52:03 +03:00
let rec gather_var_sigs acc modules =
(* Scope vars from imported modules need to be accessible directly for
definitions through submodules *)
ModuleName.Map.fold
(fun _modname mctx acc ->
let acc = gather_var_sigs acc mctx.modules in
ScopeVar.Map.union (fun _ _ -> assert false) acc mctx.var_typs)
modules acc
in
let ctxt =
{ ctxt with var_typs = gather_var_sigs ScopeVar.Map.empty ctxt.modules }
in
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
let ctxt =
List.fold_left
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(process_law_structure process_name_item)
ctxt prgm.program_items
Beginning to refactor the UID system
2020-09-12 21:22:47 +03:00
in
Fix #47
2021-03-12 19:07:25 +03:00
let ctxt =
List.fold_left
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(process_law_structure process_decl_item)
Fix #47
2021-03-12 19:07:25 +03:00
ctxt prgm.program_items
in
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
let ctxt =
List.fold_left
Implement module lookups for scopes, structs, and enums
2023-08-10 17:52:39 +03:00
(process_law_structure process_use_item)
Added labels and exceptions to surface syntax
2020-12-18 15:13:51 +03:00
ctxt prgm.program_items
in
Implmemented enum desugaring but parser error
2020-12-06 19:48:15 +03:00
ctxt
Reference in New Issue Copy Permalink