QPQ-AG/sophia
10
0
Fork 0
Code Issues 41 Pull Requests 5 Actions Packages Projects Releases 16 Wiki Activity

Rename ets_manager and type_utils

Browse Source
This commit is contained in:
Gaith Hallak 2023-04-24 16:30:50 +03:00
parent a91470fe3c
commit 4a8870fb1d
6 changed files with 130 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
src/aeso_ast_infer_types.erl
View File

@ -582,7 +582,7 @@ lookup_record_field(Env, FieldName, Kind) ->
lookup_record_field_arity(Env, FieldName, Arity, Kind) ->
Fields = lookup_record_field(Env, FieldName, Kind),
[ Fld || Fld = #field_info{ field_t = FldType } <- Fields,
fun_arity(aeso_type_utils:dereference_deep(FldType)) == Arity ].
fun_arity(aeso_tc_type_utils:dereference_deep(FldType)) == Arity ].
is_private(Ann) -> proplists:get_value(private, Ann, false).
@ -690,7 +690,7 @@ global_env() ->
{typed, Ann,
{app, Ann,
{typed, Ann, {qid, Ann, ["Call","gas_left"]},
aeso_type_utils:typesig_to_fun_t(Fun([], Int))
aeso_tc_type_utils:typesig_to_fun_t(Fun([], Int))
},
[]}, Int
}}
@ -931,21 +931,21 @@ infer([], Options) ->
type_error({no_decls, proplists:get_value(src_file, Options, no_file)}),
destroy_and_report_type_errors(init_env(Options));
infer(Contracts, Options) ->
aeso_ets_manager:ets_init(), %% Init the ETS table state
aeso_tc_ets_manager:ets_init(), %% Init the ETS table state
try
Env = init_env(Options),
create_options(Options),
aeso_ets_manager:ets_new(defined_contracts, [bag]),
aeso_ets_manager:ets_new(type_vars, [set]),
aeso_ets_manager:ets_new(warnings, [bag]),
aeso_ets_manager:ets_new(type_vars_variance, [set]),
aeso_ets_manager:ets_new(functions_to_implement, [set]),
aeso_tc_ets_manager:ets_new(defined_contracts, [bag]),
aeso_tc_ets_manager:ets_new(type_vars, [set]),
aeso_tc_ets_manager:ets_new(warnings, [bag]),
aeso_tc_ets_manager:ets_new(type_vars_variance, [set]),
aeso_tc_ets_manager:ets_new(functions_to_implement, [set]),
%% Set the variance for builtin types
aeso_ets_manager:ets_insert(type_vars_variance, {"list", [covariant]}),
aeso_ets_manager:ets_insert(type_vars_variance, {"option", [covariant]}),
aeso_ets_manager:ets_insert(type_vars_variance, {"map", [covariant, covariant]}),
aeso_ets_manager:ets_insert(type_vars_variance, {"oracle", [contravariant, covariant]}),
aeso_ets_manager:ets_insert(type_vars_variance, {"oracle_query", [covariant, covariant]}),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {"list", [covariant]}),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {"option", [covariant]}),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {"map", [covariant, covariant]}),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {"oracle", [contravariant, covariant]}),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {"oracle_query", [covariant, covariant]}),
when_warning(warn_unused_functions, fun() -> create_unused_functions() end),
check_modifiers(Env, Contracts),
@ -955,7 +955,7 @@ infer(Contracts, Options) ->
{Env1, Decls} = infer1(Env, Contracts1, [], Options),
when_warning(warn_unused_functions, fun() -> destroy_and_report_unused_functions() end),
when_option(warn_error, fun() -> destroy_and_report_warnings_as_type_errors() end),
WarningsUnsorted = lists:map(fun mk_warning/1, aeso_ets_manager:ets_tab2list(warnings)),
WarningsUnsorted = lists:map(fun mk_warning/1, aeso_tc_ets_manager:ets_tab2list(warnings)),
Warnings = aeso_warnings:sort_warnings(WarningsUnsorted),
{Env2, DeclsFolded, DeclsUnfolded} =
case proplists:get_value(dont_unfold, Options, false) of
@ -968,7 +968,7 @@ infer(Contracts, Options) ->
true -> {Env2, DeclsFolded, DeclsUnfolded, Warnings}
end
after
aeso_ets_manager:clean_up_ets()
aeso_tc_ets_manager:clean_up_ets()
end.
-spec infer1(env(), [aeso_syntax:decl()], [aeso_syntax:decl()], list(option())) ->
@ -987,7 +987,7 @@ infer1(Env0, [Contract0 = {Contract, Ann, ConName, Impls, Code} | Rest], Acc, Op
contract_interface -> contract_interface
end,
case What of
contract -> aeso_ets_manager:ets_insert(defined_contracts, {qname(ConName)});
contract -> aeso_tc_ets_manager:ets_insert(defined_contracts, {qname(ConName)});
contract_interface -> ok
end,
check_contract_preserved_payability(Env, ConName, Ann, Impls, Acc, What),
@ -1041,7 +1041,7 @@ check_contract_preserved_payability(Env, ContractName, ContractAnn, Impls, Defin
report_unimplemented_functions(Env, ContractName) ->
create_type_errors(),
[ type_error({unimplemented_interface_function, ContractName, name(I), FunName})
|| {FunName, I, _} <- aeso_ets_manager:ets_tab2list(functions_to_implement) ],
|| {FunName, I, _} <- aeso_tc_ets_manager:ets_tab2list(functions_to_implement) ],
destroy_and_report_type_errors(Env).
%% Return a list of all function declarations to be implemented, given the list
@ -1076,8 +1076,8 @@ functions_to_implement(Impls, DefinedContracts) ->
populate_functions_to_implement(Env, ContractName, Impls, DefinedContracts) ->
create_type_errors(),
[ begin
Inserted = aeso_ets_manager:ets_insert_new(functions_to_implement, {name(Id), I, Decl}),
[{_, I2, _}] = aeso_ets_manager:ets_lookup(functions_to_implement, name(Id)),
Inserted = aeso_tc_ets_manager:ets_insert_new(functions_to_implement, {name(Id), I, Decl}),
[{_, I2, _}] = aeso_tc_ets_manager:ets_lookup(functions_to_implement, name(Id)),
Inserted orelse type_error({interface_implementation_conflict, ContractName, I, I2, Id})
end || {I, Decl = {fun_decl, _, Id, _}} <- functions_to_implement(Impls, DefinedContracts) ],
destroy_and_report_type_errors(Env).
@ -1250,14 +1250,14 @@ check_typedef_sccs(Env, TypeMap, [{acyclic, Name} | SCCs], Acc) ->
type_error({empty_record_definition, Ann, Name}),
check_typedef_sccs(Env1, TypeMap, SCCs, Acc1);
{record_t, Fields} ->
aeso_ets_manager:ets_insert(type_vars_variance, {Env#env.namespace ++ qname(D),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {Env#env.namespace ++ qname(D),
infer_type_vars_variance(Xs, Fields)}),
%% check_type to get qualified name
RecTy = check_type(Env1, app_t(Ann, D, Xs)),
Env2 = check_fields(Env1, TypeMap, RecTy, Fields),
check_typedef_sccs(Env2, TypeMap, SCCs, Acc1);
{variant_t, Cons} ->
aeso_ets_manager:ets_insert(type_vars_variance, {Env#env.namespace ++ qname(D),
aeso_tc_ets_manager:ets_insert(type_vars_variance, {Env#env.namespace ++ qname(D),
infer_type_vars_variance(Xs, Cons)}),
Target = check_type(Env1, app_t(Ann, D, Xs)),
ConType = fun([]) -> Target; (Args) -> {type_sig, Ann, none, [], Args, Target} end,
@ -1306,7 +1306,7 @@ infer_type_vars_variance(Types)
when is_list(Types) ->
lists:flatten([infer_type_vars_variance(T) || T <- Types]);
infer_type_vars_variance({app_t, _, Type, Args}) ->
Variances = case aeso_ets_manager:ets_lookup(type_vars_variance, qname(Type)) of
Variances = case aeso_tc_ets_manager:ets_lookup(type_vars_variance, qname(Type)) of
[{_, Vs}] -> Vs;
_ -> lists:duplicate(length(Args), covariant)
end,
@ -1625,7 +1625,7 @@ check_fundecl(Env, {fun_decl, Ann, Id = {id, _, Name}, Type}) ->
FunSig :: typesig().
register_implementation(Id, Sig) ->
Name = name(Id),
case aeso_ets_manager:ets_lookup(functions_to_implement, Name) of
case aeso_tc_ets_manager:ets_lookup(functions_to_implement, Name) of
[{Name, Interface, Decl = {fun_decl, _, DeclId, _}}] ->
DeclStateful = aeso_syntax:get_ann(stateful, Decl, false),
DeclPayable = aeso_syntax:get_ann(payable, Decl, false),
@ -1643,7 +1643,7 @@ register_implementation(Id, Sig) ->
[ type_error({entrypoint_must_be_payable, Id, DeclId, Interface})
|| not SigPayable andalso DeclPayable ],
aeso_ets_manager:ets_delete(functions_to_implement, Name);
aeso_tc_ets_manager:ets_delete(functions_to_implement, Name);
[] ->
true;
_ ->
@ -1656,7 +1656,7 @@ infer_nonrec(Env, LetFun) ->
check_special_funs(Env, NewLetFun),
register_implementation(get_letfun_id(LetFun), Sig),
solve_then_destroy_and_report_unsolved_constraints(Env),
Result = {TypeSig, _} = aeso_type_utils:instantiate(NewLetFun),
Result = {TypeSig, _} = aeso_tc_type_utils:instantiate(NewLetFun),
print_typesig(TypeSig),
Result.
@ -1683,16 +1683,16 @@ infer_letrec(Env, Defs) ->
Res = {{Name, TypeSig}, LetFun} = infer_letfun(ExtendEnv, LF),
register_implementation(get_letfun_id(LetFun), TypeSig),
Got = proplists:get_value(Name, Funs),
Expect = aeso_type_utils:typesig_to_fun_t(TypeSig),
Expect = aeso_tc_type_utils:typesig_to_fun_t(TypeSig),
unify(Env, Got, Expect, {check_typesig, Name, Got, Expect}),
solve_constraints(Env),
?PRINT_TYPES("Checked ~s : ~s\n",
[Name, pp(aeso_type_utils:dereference_deep(Got))]),
[Name, pp(aeso_tc_type_utils:dereference_deep(Got))]),
Res
end || LF <- Defs ],
solve_then_destroy_and_report_unsolved_constraints(Env),
TypeSigs = aeso_type_utils:instantiate([Sig || {Sig, _} <- Inferred]),
NewDefs = aeso_type_utils:instantiate([D || {_, D} <- Inferred]),
TypeSigs = aeso_tc_type_utils:instantiate([Sig || {Sig, _} <- Inferred]),
NewDefs = aeso_tc_type_utils:instantiate([D || {_, D} <- Inferred]),
[print_typesig(S) || S <- TypeSigs],
{TypeSigs, NewDefs}.
@ -1704,7 +1704,7 @@ infer_letfun(Env = #env{ namespace = Namespace }, {fun_clauses, Ann, Fun = {id,
{NameSigs, Clauses1} = lists:unzip([ infer_letfun1(Env, Clause) || Clause <- Clauses ]),
{_, Sigs = [Sig | _]} = lists:unzip(NameSigs),
_ = [ begin
ClauseT = aeso_type_utils:typesig_to_fun_t(ClauseSig),
ClauseT = aeso_tc_type_utils:typesig_to_fun_t(ClauseSig),
unify(Env, ClauseT, Type1, {check_typesig, Name, ClauseT, Type1})
end || ClauseSig <- Sigs ],
{{Name, Sig}, desugar_clauses(Ann, Fun, Sig, Clauses1)};
@ -1987,7 +1987,7 @@ infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, E}|Rest]}) ->
};
infer_expr(Env, {list_comp, AsLC, Yield, [Def={letfun, AsLF, _, _, _, _}|Rest]}) ->
{{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
FunT = aeso_type_utils:typesig_to_fun_t(TypeSig),
FunT = aeso_tc_type_utils:typesig_to_fun_t(TypeSig),
NewE = bind_var({id, AsLF, Name}, FunT, Env),
{typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
infer_expr(NewE, {list_comp, AsLC, Yield, Rest}),
@ -2030,7 +2030,7 @@ infer_expr(Env, {app, Ann, Fun, Args0} = App) ->
general_type = GeneralResultType,
specialized_type = ResultType,
context = {check_return, App} }),
{typed, Ann, {app, Ann, NewFun1, NamedArgs1 ++ NewArgs}, aeso_type_utils:dereference(ResultType)}
{typed, Ann, {app, Ann, NewFun1, NamedArgs1 ++ NewArgs}, aeso_tc_type_utils:dereference(ResultType)}
end;
infer_expr(Env, {'if', Attrs, Cond, Then, Else}) ->
NewCond = check_expr(Env, Cond, {id, Attrs, "bool"}),
@ -2363,7 +2363,7 @@ infer_block(Env, _, [E], BlockType) ->
[check_expr(Env, E, BlockType)];
infer_block(Env, Attrs, [Def={letfun, Ann, _, _, _, _}|Rest], BlockType) ->
{{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
FunT = aeso_type_utils:typesig_to_fun_t(TypeSig),
FunT = aeso_tc_type_utils:typesig_to_fun_t(TypeSig),
NewE = bind_var({id, Ann, Name}, FunT, Env),
[LetFun|infer_block(NewE, Attrs, Rest, BlockType)];
infer_block(Env, _, [{letval, Attrs, Pattern, E}|Rest], BlockType) ->
@ -2389,7 +2389,7 @@ infer_const(Env, {letval, Ann, Id = {id, AnnId, _}, Expr}) ->
solve_then_destroy_and_report_unsolved_constraints(Env),
IdType = setelement(2, Type, AnnId),
NewId = {typed, aeso_syntax:get_ann(Id), Id, IdType},
aeso_type_utils:instantiate({letval, Ann, NewId, NewExpr}).
aeso_tc_type_utils:instantiate({letval, Ann, NewId, NewExpr}).
infer_infix({BoolOp, As})
when BoolOp =:= '&&'; BoolOp =:= '||' ->
@ -2464,13 +2464,13 @@ free_vars(L) when is_list(L) ->
%% Options
create_options(Options) ->
aeso_ets_manager:ets_new(options, [set]),
aeso_tc_ets_manager:ets_new(options, [set]),
Tup = fun(Opt) when is_atom(Opt) -> {Opt, true};
(Opt) when is_tuple(Opt) -> Opt end,
aeso_ets_manager:ets_insert(options, lists:map(Tup, Options)).
aeso_tc_ets_manager:ets_insert(options, lists:map(Tup, Options)).
get_option(Key, Default) ->
case aeso_ets_manager:ets_lookup(options, Key) of
case aeso_tc_ets_manager:ets_lookup(options, Key) of
[{Key, Val}] -> Val;
_ -> Default
end.
@ -2481,17 +2481,17 @@ when_option(Opt, Do) ->
%% -- Constraints --
create_constraints() ->
aeso_ets_manager:ets_new(constraints, [ordered_set]).
aeso_tc_ets_manager:ets_new(constraints, [ordered_set]).
-spec add_constraint(constraint() | [constraint()]) -> true.
add_constraint(Constraint) ->
aeso_ets_manager:ets_insert_ordered(constraints, Constraint).
aeso_tc_ets_manager:ets_insert_ordered(constraints, Constraint).
get_constraints() ->
aeso_ets_manager:ets_tab2list_ordered(constraints).
aeso_tc_ets_manager:ets_tab2list_ordered(constraints).
destroy_constraints() ->
aeso_ets_manager:ets_delete(constraints).
aeso_tc_ets_manager:ets_delete(constraints).
-spec solve_constraints(env()) -> ok.
solve_constraints(Env) ->
@ -2503,7 +2503,7 @@ solve_constraints(Env) ->
field_t = FieldType,
kind = Kind,
context = When }) ->
Arity = fun_arity(aeso_type_utils:dereference_deep(FieldType)),
Arity = fun_arity(aeso_tc_type_utils:dereference_deep(FieldType)),
FieldInfos = case Arity of
none -> lookup_record_field(Env, FieldName, Kind);
_ -> lookup_record_field_arity(Env, FieldName, Arity, Kind)
@ -2578,7 +2578,7 @@ destroy_and_report_unsolved_constraints(Env) ->
(_) -> false
end, OtherCs5),
Unsolved = [ S || S <- [ solve_constraint(Env, aeso_type_utils:dereference_deep(C)) || C <- NamedArgCs ],
Unsolved = [ S || S <- [ solve_constraint(Env, aeso_tc_type_utils:dereference_deep(C)) || C <- NamedArgCs ],
S == unsolved ],
[ type_error({unsolved_named_argument_constraint, C}) || C <- Unsolved ],
@ -2630,8 +2630,8 @@ check_named_argument_constraint(Env,
general_type = GenType,
specialized_type = SpecType,
context = {check_return, App} }) ->
NamedArgsT = aeso_type_utils:dereference(NamedArgsT0),
case aeso_type_utils:dereference(NamedArgsT0) of
NamedArgsT = aeso_tc_type_utils:dereference(NamedArgsT0),
case aeso_tc_type_utils:dereference(NamedArgsT0) of
[_ | _] = NamedArgsT ->
GetVal = fun(Name, Default) ->
hd([ Val || {named_arg, _, {id, _, N}, Val} <- NamedArgs, N == Name] ++
@ -2646,7 +2646,7 @@ check_named_argument_constraint(Env,
end.
specialize_dependent_type(Env, Type) ->
case aeso_type_utils:dereference(Type) of
case aeso_tc_type_utils:dereference(Type) of
{if_t, _, {id, _, Arg}, Then, Else} ->
Val = maps:get(Arg, Env),
case Val of
@ -2687,7 +2687,7 @@ solve_constraint(Env, C = #field_constraint{record_t = RecType,
C
end;
_ ->
type_error({not_a_record_type, aeso_type_utils:instantiate(RecType), When}),
type_error({not_a_record_type, aeso_tc_type_utils:instantiate(RecType), When}),
not_solved
end;
solve_constraint(Env, C = #dependent_type_constraint{}) ->
@ -2696,9 +2696,9 @@ solve_constraint(Env, C = #named_argument_constraint{}) ->
check_named_argument_constraint(Env, C);
solve_constraint(_Env, {is_bytes, _}) -> ok;
solve_constraint(Env, {add_bytes, Ann, _, A0, B0, C0}) ->
A = unfold_types_in_type(Env, aeso_type_utils:dereference(A0)),
B = unfold_types_in_type(Env, aeso_type_utils:dereference(B0)),
C = unfold_types_in_type(Env, aeso_type_utils:dereference(C0)),
A = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(A0)),
B = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(B0)),
C = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(C0)),
case {A, B, C} of
{{bytes_t, _, M}, {bytes_t, _, N}, _} -> unify(Env, {bytes_t, Ann, M + N}, C, {at, Ann});
{{bytes_t, _, M}, _, {bytes_t, _, R}} when R >= M -> unify(Env, {bytes_t, Ann, R - M}, B, {at, Ann});
@ -2718,16 +2718,16 @@ check_bytes_constraints(Env, Constraints) ->
[ check_bytes_constraint(Env, C) || C <- Constraints, not Skip(C) ].
check_bytes_constraint(Env, {is_bytes, Type}) ->
Type1 = unfold_types_in_type(Env, aeso_type_utils:instantiate(Type)),
Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
case Type1 of
{bytes_t, _, _} -> ok;
_ ->
type_error({unknown_byte_length, Type})
end;
check_bytes_constraint(Env, {add_bytes, Ann, Fun, A0, B0, C0}) ->
A = unfold_types_in_type(Env, aeso_type_utils:instantiate(A0)),
B = unfold_types_in_type(Env, aeso_type_utils:instantiate(B0)),
C = unfold_types_in_type(Env, aeso_type_utils:instantiate(C0)),
A = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(A0)),
B = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(B0)),
C = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(C0)),
case {A, B, C} of
{{bytes_t, _, _M}, {bytes_t, _, _N}, {bytes_t, _, _R}} ->
ok; %% If all are solved we checked M + N == R in solve_constraint.
@ -2737,7 +2737,7 @@ check_bytes_constraint(Env, {add_bytes, Ann, Fun, A0, B0, C0}) ->
check_aens_resolve_constraints(_Env, []) ->
ok;
check_aens_resolve_constraints(Env, [{aens_resolve_type, Type} | Rest]) ->
Type1 = unfold_types_in_type(Env, aeso_type_utils:instantiate(Type)),
Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
{app_t, _, {id, _, "option"}, [Type2]} = Type1,
case Type2 of
{id, _, "string"} -> ok;
@ -2752,7 +2752,7 @@ check_aens_resolve_constraints(Env, [{aens_resolve_type, Type} | Rest]) ->
check_oracle_type_constraints(_Env, []) ->
ok;
check_oracle_type_constraints(Env, [{oracle_type, Ann, OType} | Rest]) ->
Type = unfold_types_in_type(Env, aeso_type_utils:instantiate(OType)),
Type = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(OType)),
{app_t, _, {id, _, "oracle"}, [QType, RType]} = Type,
ensure_monomorphic(QType, {invalid_oracle_type, polymorphic, query, Ann, Type}),
ensure_monomorphic(RType, {invalid_oracle_type, polymorphic, response, Ann, Type}),
@ -2768,7 +2768,7 @@ check_record_create_constraints(Env, [C | Cs]) ->
record_t = Type,
fields = Fields,
context = When } = C,
Type1 = unfold_types_in_type(Env, aeso_type_utils:instantiate(Type)),
Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
try lookup_type(Env, record_type_name(Type1)) of
{_QId, {_Ann, {_Args, {record_t, RecFields}}}} ->
ActualNames = [ Fld || {field_t, _, {id, _, Fld}, _} <- RecFields ],
@ -2785,12 +2785,12 @@ check_record_create_constraints(Env, [C | Cs]) ->
check_record_create_constraints(Env, Cs).
is_contract_defined(C) ->
aeso_ets_manager:ets_lookup(defined_contracts, qname(C)) =/= [].
aeso_tc_ets_manager:ets_lookup(defined_contracts, qname(C)) =/= [].
check_is_contract_constraints(_Env, []) -> ok;
check_is_contract_constraints(Env, [C | Cs]) ->
#is_contract_constraint{ contract_t = Type, context = Cxt, force_def = ForceDef } = C,
Type1 = unfold_types_in_type(Env, aeso_type_utils:instantiate(Type)),
Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
TypeName = record_type_name(Type1),
case lookup_type(Env, TypeName) of
{_, {_Ann, {[], {contract_t, _}}}} ->
@ -2819,10 +2819,10 @@ solve_unknown_record_types(Env, Unknown) ->
-spec solve_known_record_types(env(), [constraint()]) -> [field_constraint()].
solve_known_record_types(Env, Constraints) ->
DerefConstraints = lists:map(fun(C = #field_constraint{record_t = RecordType}) ->
C#field_constraint{record_t = aeso_type_utils:dereference(RecordType)};
(C) -> aeso_type_utils:dereference_deep(C)
C#field_constraint{record_t = aeso_tc_type_utils:dereference(RecordType)};
(C) -> aeso_tc_type_utils:dereference_deep(C)
end, Constraints),
SolvedConstraints = lists:map(fun(C) -> solve_constraint(Env, aeso_type_utils:dereference_deep(C)) end, DerefConstraints),
SolvedConstraints = lists:map(fun(C) -> solve_constraint(Env, aeso_tc_type_utils:dereference_deep(C)) end, DerefConstraints),
Unsolved = DerefConstraints--SolvedConstraints,
lists:filter(fun(#field_constraint{}) -> true; (_) -> false end, Unsolved).
@ -2997,8 +2997,8 @@ unify0(Env, A, B, Variance, When) ->
{check_expr, E, _, _} -> [{ann, aeso_syntax:get_ann(E)}];
_ -> []
end,
A1 = aeso_type_utils:dereference(unfold_types_in_type(Env, A, Options)),
B1 = aeso_type_utils:dereference(unfold_types_in_type(Env, B, Options)),
A1 = aeso_tc_type_utils:dereference(unfold_types_in_type(Env, A, Options)),
B1 = aeso_tc_type_utils:dereference(unfold_types_in_type(Env, B, Options)),
unify1(Env, A1, B1, Variance, When).
unify1(_Env, {uvar, _, R}, {uvar, _, R}, _Variance, _When) ->
@ -3016,7 +3016,7 @@ unify1(Env, {uvar, A, R}, T, _Variance, When) ->
end,
false;
false ->
aeso_ets_manager:ets_insert(type_vars, {R, T}),
aeso_tc_ets_manager:ets_insert(type_vars, {R, T}),
true
end;
unify1(Env, T, {uvar, A, R}, Variance, When) ->
@ -3075,7 +3075,7 @@ unify1(Env, {fun_t, _, Named1, Args1, Result1}, {fun_t, _, Named2, Args2, Result
unify0(Env, Result1, Result2, Variance, When);
unify1(Env, {app_t, _, {Tag, _, F}, Args1}, {app_t, _, {Tag, _, F}, Args2}, Variance, When)
when length(Args1) == length(Args2), Tag == id orelse Tag == qid ->
Variances = case aeso_ets_manager:ets_lookup(type_vars_variance, F) of
Variances = case aeso_tc_ets_manager:ets_lookup(type_vars_variance, F) of
[{_, Vs}] ->
case Variance of
contravariant -> lists:map(fun opposite_variance/1, Vs);
@ -3131,7 +3131,7 @@ is_subtype(Env, Child, Base) ->
end.
occurs_check(R, T) ->
occurs_check1(R, aeso_type_utils:dereference(T)).
occurs_check1(R, aeso_tc_type_utils:dereference(T)).
occurs_check1(R, {uvar, _, R1}) -> R == R1;
occurs_check1(_, {id, _, _}) -> false;
@ -3162,10 +3162,10 @@ fresh_uvar(Attrs) ->
{uvar, Attrs, make_ref()}.
create_freshen_tvars() ->
aeso_ets_manager:ets_new(freshen_tvars, [set]).
aeso_tc_ets_manager:ets_new(freshen_tvars, [set]).
destroy_freshen_tvars() ->
aeso_ets_manager:ets_delete(freshen_tvars).
aeso_tc_ets_manager:ets_delete(freshen_tvars).
freshen_type(Ann, Type) ->
create_freshen_tvars(),
@ -3177,11 +3177,11 @@ freshen(Type) ->
freshen(aeso_syntax:get_ann(Type), Type).
freshen(Ann, {tvar, _, Name}) ->
NewT = case aeso_ets_manager:ets_lookup(freshen_tvars, Name) of
NewT = case aeso_tc_ets_manager:ets_lookup(freshen_tvars, Name) of
[] -> fresh_uvar(Ann);
[{Name, T}] -> T
end,
aeso_ets_manager:ets_insert(freshen_tvars, {Name, NewT}),
aeso_tc_ets_manager:ets_insert(freshen_tvars, {Name, NewT}),
NewT;
freshen(Ann, {bytes_t, _, any}) ->
X = fresh_uvar(Ann),
@ -3195,7 +3195,7 @@ freshen(_, X) ->
X.
freshen_type_sig(Ann, TypeSig = {type_sig, _, Constr, _, _, _}) ->
FunT = freshen_type(Ann, aeso_type_utils:typesig_to_fun_t(TypeSig)),
FunT = freshen_type(Ann, aeso_tc_type_utils:typesig_to_fun_t(TypeSig)),
apply_typesig_constraint(Ann, Constr, FunT),
FunT.
@ -3218,7 +3218,7 @@ when_warning(Warn, Do) ->
type_error({unknown_warning, Warn}),
destroy_and_report_type_errors(global_env());
true ->
case aeso_ets_manager:ets_tab_exists(warnings) of
case aeso_tc_ets_manager:ets_tab_exists(warnings) of
true ->
IsEnabled = get_option(Warn, false),
IsAll = get_option(warn_all, false) andalso lists:member(Warn, all_warnings()),

20
src/aeso_tc_errors.erl
View File

@ -37,15 +37,15 @@ cannot_unify(A, B, Cxt, When) ->
type_error({cannot_unify, A, B, Cxt, When}).
type_error(Err) ->
aeso_ets_manager:ets_insert(type_errors, Err).
aeso_tc_ets_manager:ets_insert(type_errors, Err).
create_type_errors() ->
aeso_ets_manager:ets_new(type_errors, [bag]).
aeso_tc_ets_manager:ets_new(type_errors, [bag]).
destroy_and_report_type_errors(Env) ->
Errors0 = lists:reverse(aeso_ets_manager:ets_tab2list(type_errors)),
Errors0 = lists:reverse(aeso_tc_ets_manager:ets_tab2list(type_errors)),
%% io:format("Type errors now: ~p\n", [Errors0]),
aeso_ets_manager:ets_delete(type_errors),
aeso_tc_ets_manager:ets_delete(type_errors),
Errors = [ mk_error(unqualify(Env, Err)) || Err <- Errors0 ],
aeso_errors:throw(Errors). %% No-op if Errors == []
@ -79,12 +79,12 @@ mk_error({mismatched_decl_in_funblock, Name, Decl}) ->
mk_t_err(pos(Decl), Msg);
mk_error({higher_kinded_typevar, T}) ->
Msg = io_lib:format("Type `~s` is a higher kinded type variable "
"(takes another type as an argument)", [pp(aeso_type_utils:instantiate(T))]
"(takes another type as an argument)", [pp(aeso_tc_type_utils:instantiate(T))]
),
mk_t_err(pos(T), Msg);
mk_error({wrong_type_arguments, X, ArityGiven, ArityReal}) ->
Msg = io_lib:format("Arity for ~s doesn't match. Expected ~p, got ~p"
, [pp(aeso_type_utils:instantiate(X)), ArityReal, ArityGiven]
, [pp(aeso_tc_type_utils:instantiate(X)), ArityReal, ArityGiven]
),
mk_t_err(pos(X), Msg);
mk_error({unnamed_map_update_with_default, Upd}) ->
@ -93,7 +93,7 @@ mk_error({unnamed_map_update_with_default, Upd}) ->
mk_error({fundecl_must_have_funtype, _Ann, Id, Type}) ->
Msg = io_lib:format("`~s` was declared with an invalid type `~s`. "
"Entrypoints and functions must have functional types"
, [pp(Id), pp(aeso_type_utils:instantiate(Type))]),
, [pp(Id), pp(aeso_tc_type_utils:instantiate(Type))]),
mk_t_err(pos(Id), Msg);
mk_error({cannot_unify, A, B, Cxt, When}) ->
VarianceContext = case Cxt of
@ -101,11 +101,11 @@ mk_error({cannot_unify, A, B, Cxt, When}) ->
_ -> io_lib:format(" in a ~p context", [Cxt])
end,
Msg = io_lib:format("Cannot unify `~s` and `~s`" ++ VarianceContext,
[pp(aeso_type_utils:instantiate(A)), pp(aeso_type_utils:instantiate(B))]),
[pp(aeso_tc_type_utils:instantiate(A)), pp(aeso_tc_type_utils:instantiate(B))]),
{Pos, Ctxt} = pp_when(When),
mk_t_err(Pos, Msg, Ctxt);
mk_error({hole_found, Ann, Type}) ->
Msg = io_lib:format("Found a hole of type `~s`", [pp(aeso_type_utils:instantiate(Type))]),
Msg = io_lib:format("Found a hole of type `~s`", [pp(aeso_tc_type_utils:instantiate(Type))]),
mk_t_err(pos(Ann), Msg);
mk_error({unbound_variable, Id}) ->
Msg = io_lib:format("Unbound variable `~s`", [pp(Id)]),
@ -377,7 +377,7 @@ mk_error({mixed_record_and_map, Expr}) ->
mk_error({named_argument_must_be_literal_bool, Name, Arg}) ->
Msg = io_lib:format("Invalid `~s` argument `~s`. "
"It must be either `true` or `false`.",
[Name, pp_expr(aeso_type_utils:instantiate(Arg))]),
[Name, pp_expr(aeso_tc_type_utils:instantiate(Arg))]),
mk_t_err(pos(Arg), Msg);
mk_error({conflicting_updates_for_field, Upd, Key}) ->
Msg = io_lib:format("Conflicting updates for field '~s'", [Key]),

2
src/aeso_ets_manager.erl → src/aeso_tc_ets_manager.erl
View File

@ -1,4 +1,4 @@
-module(aeso_ets_manager).
-module(aeso_tc_ets_manager).
-export([ ets_init/0
, ets_new/2

32
src/aeso_tc_pp.erl
View File

@ -40,10 +40,10 @@ pp_when({check_typesig, Name, Inferred, Given}) ->
io_lib:format("when checking the definition of `~s`\n"
" inferred type: `~s`\n"
" given type: `~s`",
[Name, pp(aeso_type_utils:instantiate(Inferred)), pp(aeso_type_utils:instantiate(Given))])};
[Name, pp(aeso_tc_type_utils:instantiate(Inferred)), pp(aeso_tc_type_utils:instantiate(Given))])};
pp_when({infer_app, Fun, NamedArgs, Args, Inferred0, ArgTypes0}) ->
Inferred = aeso_type_utils:instantiate(Inferred0),
ArgTypes = aeso_type_utils:instantiate(ArgTypes0),
Inferred = aeso_tc_type_utils:instantiate(Inferred0),
ArgTypes = aeso_tc_type_utils:instantiate(ArgTypes0),
{pos(Fun),
io_lib:format("when checking the application of\n"
" `~s`\n"
@ -53,8 +53,8 @@ pp_when({infer_app, Fun, NamedArgs, Args, Inferred0, ArgTypes0}) ->
[ ["\n ", "`" ++ pp_typed("", Arg, ArgT) ++ "`"]
|| {Arg, ArgT} <- lists:zip(Args, ArgTypes) ] ])};
pp_when({field_constraint, FieldType0, InferredType0, Fld}) ->
FieldType = aeso_type_utils:instantiate(FieldType0),
InferredType = aeso_type_utils:instantiate(InferredType0),
FieldType = aeso_tc_type_utils:instantiate(FieldType0),
InferredType = aeso_tc_type_utils:instantiate(InferredType0),
{pos(Fld),
case Fld of
{var_args, _Ann, _Fun} ->
@ -78,8 +78,8 @@ pp_when({field_constraint, FieldType0, InferredType0, Fld}) ->
pp_type(" ", InferredType)])
end};
pp_when({record_constraint, RecType0, InferredType0, Fld}) ->
RecType = aeso_type_utils:instantiate(RecType0),
InferredType = aeso_type_utils:instantiate(InferredType0),
RecType = aeso_tc_type_utils:instantiate(RecType0),
InferredType = aeso_tc_type_utils:instantiate(InferredType0),
{Pos, WhyRec} = pp_why_record(Fld),
case Fld of
{var_args, _Ann, _Fun} ->
@ -106,20 +106,20 @@ pp_when({record_constraint, RecType0, InferredType0, Fld}) ->
pp_type(" ", RecType), WhyRec])}
end;
pp_when({if_branches, Then, ThenType0, Else, ElseType0}) ->
{ThenType, ElseType} = aeso_type_utils:instantiate({ThenType0, ElseType0}),
{ThenType, ElseType} = aeso_tc_type_utils:instantiate({ThenType0, ElseType0}),
Branches = [ {Then, ThenType} | [ {B, ElseType} || B <- if_branches(Else) ] ],
{pos(element(1, hd(Branches))),
io_lib:format("when comparing the types of the if-branches\n"
"~s", [ [ io_lib:format("~s (at ~s)\n", [pp_typed(" - ", B, BType), pp_loc(B)])
|| {B, BType} <- Branches ] ])};
pp_when({case_pat, Pat, PatType0, ExprType0}) ->
{PatType, ExprType} = aeso_type_utils:instantiate({PatType0, ExprType0}),
{PatType, ExprType} = aeso_tc_type_utils:instantiate({PatType0, ExprType0}),
{pos(Pat),
io_lib:format("when checking the type of the pattern `~s` against the expected type `~s`",
[pp_typed("", Pat, PatType),
pp_type(ExprType)])};
pp_when({check_expr, Expr, Inferred0, Expected0}) ->
{Inferred, Expected} = aeso_type_utils:instantiate({Inferred0, Expected0}),
{Inferred, Expected} = aeso_tc_type_utils:instantiate({Inferred0, Expected0}),
{pos(Expr),
io_lib:format("when checking the type of the expression `~s` against the expected type `~s`",
[pp_typed("", Expr, Inferred), pp_type(Expected)])};
@ -127,7 +127,7 @@ pp_when({checking_init_type, Ann}) ->
{pos(Ann),
io_lib:format("when checking that `init` returns a value of type `state`", [])};
pp_when({list_comp, BindExpr, Inferred0, Expected0}) ->
{Inferred, Expected} = aeso_type_utils:instantiate({Inferred0, Expected0}),
{Inferred, Expected} = aeso_tc_type_utils:instantiate({Inferred0, Expected0}),
{pos(BindExpr),
io_lib:format("when checking rvalue of list comprehension binding `~s` against type `~s`",
[pp_typed("", BindExpr, Inferred), pp_type(Expected)])};
@ -138,14 +138,14 @@ pp_when({check_named_arg_constraint, C}) ->
[pp_typed("", Arg, Type), pp_type(aeso_ast_infer_types:get_named_argument_constraint_type(C))]),
{pos(Arg), Err};
pp_when({checking_init_args, Ann, Con0, ArgTypes0}) ->
Con = aeso_type_utils:instantiate(Con0),
ArgTypes = aeso_type_utils:instantiate(ArgTypes0),
Con = aeso_tc_type_utils:instantiate(Con0),
ArgTypes = aeso_tc_type_utils:instantiate(ArgTypes0),
{pos(Ann),
io_lib:format("when checking arguments of `~s`'s init entrypoint to match\n(~s)",
[pp_type(Con), string:join([pp_type(A) || A <- ArgTypes], ", ")])
};
pp_when({return_contract, App, Con0}) ->
Con = aeso_type_utils:instantiate(Con0),
Con = aeso_tc_type_utils:instantiate(Con0),
{pos(App)
, io_lib:format("when checking that expression returns contract of type `~s`", [pp_type(Con)])
};
@ -178,7 +178,7 @@ pp_why_record({proj, _Ann, Rec, FldName}) ->
io_lib:format("arising from the projection of the field `~s`",
[pp(FldName)])}.
pp_typed(Label, E, T = {type_sig, _, _, _, _, _}) -> pp_typed(Label, E, aeso_type_utils:typesig_to_fun_t(T));
pp_typed(Label, E, T = {type_sig, _, _, _, _, _}) -> pp_typed(Label, E, aeso_tc_type_utils:typesig_to_fun_t(T));
pp_typed(Label, {typed, _, Expr, _}, Type) ->
pp_typed(Label, Expr, Type);
pp_typed(Label, Expr, Type) ->
@ -205,7 +205,7 @@ pp_loc(T) ->
end.
pp(T = {type_sig, _, _, _, _, _}) ->
pp(aeso_type_utils:typesig_to_fun_t(T));
pp(aeso_tc_type_utils:typesig_to_fun_t(T));
pp([]) ->
"";
pp([T]) ->

10
src/aeso_type_utils.erl → src/aeso_tc_type_utils.erl
View File

@ -1,4 +1,4 @@
-module(aeso_type_utils).
-module(aeso_tc_type_utils).
-export([ dereference/1
, dereference_deep/1
@ -10,7 +10,7 @@ typesig_to_fun_t({type_sig, Ann, _Constr, Named, Args, Res}) ->
{fun_t, Ann, Named, Args, Res}.
dereference(T = {uvar, _, R}) ->
case aeso_ets_manager:ets_lookup(type_vars, R) of
case aeso_tc_ets_manager:ets_lookup(type_vars, R) of
[] ->
T;
[{R, Type}] ->
@ -33,16 +33,16 @@ instantiate(E) ->
instantiate1(dereference(E)).
instantiate1({uvar, Attr, R}) ->
Next = proplists:get_value(next, aeso_ets_manager:ets_lookup(type_vars, next), 0),
Next = proplists:get_value(next, aeso_tc_ets_manager:ets_lookup(type_vars, next), 0),
TVar = {tvar, Attr, "'" ++ integer_to_tvar(Next)},
aeso_ets_manager:ets_insert(type_vars, [{next, Next + 1}, {R, TVar}]),
aeso_tc_ets_manager:ets_insert(type_vars, [{next, Next + 1}, {R, TVar}]),
TVar;
instantiate1({fun_t, Ann, Named, Args, Ret}) ->
case dereference(Named) of
{uvar, _, R} ->
%% Uninstantiated named args map to the empty list
NoNames = [],
aeso_ets_manager:ets_insert(type_vars, [{R, NoNames}]),
aeso_tc_ets_manager:ets_insert(type_vars, [{R, NoNames}]),
{fun_t, Ann, NoNames, instantiate(Args), instantiate(Ret)};
Named1 ->
{fun_t, Ann, instantiate1(Named1), instantiate(Args), instantiate(Ret)}

50
src/aeso_tc_warnings.erl
View File

@ -59,14 +59,14 @@ potential_unused_include(Ann, SrcFile) ->
true ->
case aeso_syntax:get_ann(file, Ann, no_file) of
no_file -> ok;
File -> aeso_ets_manager:ets_insert(warnings, {unused_include, File, SrcFile})
File -> aeso_tc_ets_manager:ets_insert(warnings, {unused_include, File, SrcFile})
end
end.
used_include(Ann) ->
case aeso_syntax:get_ann(file, Ann, no_file) of
no_file -> ok;
File -> aeso_ets_manager:ets_match_delete(warnings, {unused_include, File, '_'})
File -> aeso_tc_ets_manager:ets_match_delete(warnings, {unused_include, File, '_'})
end.
%% Warnings (Unused stateful)
@ -74,30 +74,30 @@ used_include(Ann) ->
potential_unused_stateful(Ann, Fun) ->
case aeso_syntax:get_ann(stateful, Ann, false) of
false -> ok;
true -> aeso_ets_manager:ets_insert(warnings, {unused_stateful, Ann, Fun})
true -> aeso_tc_ets_manager:ets_insert(warnings, {unused_stateful, Ann, Fun})
end.
used_stateful(Fun) ->
aeso_ets_manager:ets_match_delete(warnings, {unused_stateful, '_', Fun}).
aeso_tc_ets_manager:ets_match_delete(warnings, {unused_stateful, '_', Fun}).
%% Warnings (Unused type defs)
potential_unused_typedefs(Namespace, TypeDefs) ->
lists:map(fun({type_def, Ann, Id, Args, _}) ->
aeso_ets_manager:ets_insert(warnings, {unused_typedef, Ann, Namespace ++ qname(Id), length(Args)}) end, TypeDefs).
aeso_tc_ets_manager:ets_insert(warnings, {unused_typedef, Ann, Namespace ++ qname(Id), length(Args)}) end, TypeDefs).
used_typedef(TypeAliasId, Arity) ->
aeso_ets_manager:ets_match_delete(warnings, {unused_typedef, '_', qname(TypeAliasId), Arity}).
aeso_tc_ets_manager:ets_match_delete(warnings, {unused_typedef, '_', qname(TypeAliasId), Arity}).
%% Warnings (Unused variables)
potential_unused_variables(Namespace, Fun, Vars0) ->
Vars = [ Var || Var = {id, _, VarName} <- Vars0, VarName /= "_" ],
lists:map(fun({id, Ann, VarName}) ->
aeso_ets_manager:ets_insert(warnings, {unused_variable, Ann, Namespace, Fun, VarName}) end, Vars).
aeso_tc_ets_manager:ets_insert(warnings, {unused_variable, Ann, Namespace, Fun, VarName}) end, Vars).
used_variable(Namespace, Fun, [VarName]) ->
aeso_ets_manager:ets_match_delete(warnings, {unused_variable, '_', Namespace, Fun, VarName});
aeso_tc_ets_manager:ets_match_delete(warnings, {unused_variable, '_', Namespace, Fun, VarName});
used_variable(_, _, _) -> ok.
%% Warnings (Unused constants)
@ -106,39 +106,39 @@ potential_unused_constants(Env, Consts) ->
case aeso_ast_infer_types:get_env_what(Env) of
namespace -> [];
_ ->
[ aeso_ets_manager:ets_insert(warnings, {unused_constant, Ann, aeso_ast_infer_types:get_env_namespace(Env), Name}) || {letval, _, {id, Ann, Name}, _} <- Consts ]
[ aeso_tc_ets_manager:ets_insert(warnings, {unused_constant, Ann, aeso_ast_infer_types:get_env_namespace(Env), Name}) || {letval, _, {id, Ann, Name}, _} <- Consts ]
end.
used_constant(Namespace = [Contract], [Contract, ConstName]) ->
aeso_ets_manager:ets_match_delete(warnings, {unused_constant, '_', Namespace, ConstName});
aeso_tc_ets_manager:ets_match_delete(warnings, {unused_constant, '_', Namespace, ConstName});
used_constant(_, _) -> ok.
%% Warnings (Unused return value)
potential_unused_return_value({typed, Ann, {app, _, {typed, _, _, {fun_t, _, _, _, {id, _, Type}}}, _}, _}) when Type /= "unit" ->
aeso_ets_manager:ets_insert(warnings, {unused_return_value, Ann});
aeso_tc_ets_manager:ets_insert(warnings, {unused_return_value, Ann});
potential_unused_return_value(_) -> ok.
%% Warnings (Unused functions)
create_unused_functions() ->
aeso_ets_manager:ets_new(function_calls, [bag]),
aeso_ets_manager:ets_new(all_functions, [set]).
aeso_tc_ets_manager:ets_new(function_calls, [bag]),
aeso_tc_ets_manager:ets_new(all_functions, [set]).
register_function_call(Caller, Callee) ->
aeso_ets_manager:ets_insert(function_calls, {Caller, Callee}).
aeso_tc_ets_manager:ets_insert(function_calls, {Caller, Callee}).
potential_unused_function(Env, Ann, FunQName, FunId) ->
case aeso_ast_infer_types:get_env_what(Env) of
namespace ->
aeso_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, not aeso_syntax:get_ann(private, Ann, false)});
aeso_tc_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, not aeso_syntax:get_ann(private, Ann, false)});
_ ->
aeso_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, aeso_syntax:get_ann(entrypoint, Ann, false)})
aeso_tc_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, aeso_syntax:get_ann(entrypoint, Ann, false)})
end.
remove_used_funs(All) ->
{Used, Unused} = lists:partition(fun({_, _, _, IsUsed}) -> IsUsed end, All),
CallsByUsed = lists:flatmap(fun({_, F, _, _}) -> aeso_ets_manager:ets_lookup(function_calls, F) end, Used),
CallsByUsed = lists:flatmap(fun({_, F, _, _}) -> aeso_tc_ets_manager:ets_lookup(function_calls, F) end, Used),
CalledFuns = sets:from_list(lists:map(fun({_, Callee}) -> Callee end, CallsByUsed)),
MarkUsedFun = fun(Fun, Acc) ->
case lists:keyfind(Fun, 2, Acc) of
@ -153,11 +153,11 @@ remove_used_funs(All) ->
end.
destroy_and_report_unused_functions() ->
AllFuns = aeso_ets_manager:ets_tab2list(all_functions),
lists:map(fun({Ann, _, FunId, _}) -> aeso_ets_manager:ets_insert(warnings, {unused_function, Ann, name(FunId)}) end,
AllFuns = aeso_tc_ets_manager:ets_tab2list(all_functions),
lists:map(fun({Ann, _, FunId, _}) -> aeso_tc_ets_manager:ets_insert(warnings, {unused_function, Ann, name(FunId)}) end,
remove_used_funs(AllFuns)),
aeso_ets_manager:ets_delete(all_functions),
aeso_ets_manager:ets_delete(function_calls).
aeso_tc_ets_manager:ets_delete(all_functions),
aeso_tc_ets_manager:ets_delete(function_calls).
%% Warnings (Shadowing)
@ -167,14 +167,14 @@ warn_potential_shadowing(Env, Ann, Name) ->
Consts = aeso_ast_infer_types:get_current_scope_consts(Env),
case proplists:get_value(Name, Vars ++ Consts, false) of
false -> ok;
{AnnOld, _} -> aeso_ets_manager:ets_insert(warnings, {shadowing, Ann, Name, AnnOld})
{AnnOld, _} -> aeso_tc_ets_manager:ets_insert(warnings, {shadowing, Ann, Name, AnnOld})
end.
%% Warnings (Division by zero)
warn_potential_division_by_zero(Ann, Op, Args) ->
case {Op, Args} of
{{'/', _}, [_, {int, _, 0}]} -> aeso_ets_manager:ets_insert(warnings, {division_by_zero, Ann});
{{'/', _}, [_, {int, _, 0}]} -> aeso_tc_ets_manager:ets_insert(warnings, {division_by_zero, Ann});
_ -> ok
end.
@ -184,12 +184,12 @@ warn_potential_negative_spend(Ann, Fun, Args) ->
case {Fun, Args} of
{ {typed, _, {qid, _, ["Chain", "spend"]}, _}
, [_, {typed, _, {app, _, {'-', _}, [{typed, _, {int, _, X}, _}]}, _}]} when X > 0 ->
aeso_ets_manager:ets_insert(warnings, {negative_spend, Ann});
aeso_tc_ets_manager:ets_insert(warnings, {negative_spend, Ann});
_ -> ok
end.
destroy_and_report_warnings_as_type_errors() ->
Warnings = [ mk_warning(Warn) || Warn <- aeso_ets_manager:ets_tab2list(warnings) ],
Warnings = [ mk_warning(Warn) || Warn <- aeso_tc_ets_manager:ets_tab2list(warnings) ],
Errors = lists:map(fun mk_t_err_from_warn/1, Warnings),
aeso_errors:throw(Errors). %% No-op if Warnings == []