From 4a8870fb1dd764ceaa1cd30ad9a68ada45134166 Mon Sep 17 00:00:00 2001 From: Gaith Hallak Date: Mon, 24 Apr 2023 16:30:50 +0300 Subject: [PATCH] Rename ets_manager and type_utils --- src/aeso_ast_infer_types.erl | 146 +++++++++--------- src/aeso_tc_errors.erl | 20 +-- ...ts_manager.erl => aeso_tc_ets_manager.erl} | 2 +- src/aeso_tc_pp.erl | 32 ++-- ..._type_utils.erl => aeso_tc_type_utils.erl} | 10 +- src/aeso_tc_warnings.erl | 50 +++--- 6 files changed, 130 insertions(+), 130 deletions(-) rename src/{aeso_ets_manager.erl => aeso_tc_ets_manager.erl} (98%) rename src/{aeso_type_utils.erl => aeso_tc_type_utils.erl} (82%) diff --git a/src/aeso_ast_infer_types.erl b/src/aeso_ast_infer_types.erl index 28fe3e8..b10d6af 100644 --- a/src/aeso_ast_infer_types.erl +++ b/src/aeso_ast_infer_types.erl @@ -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()), diff --git a/src/aeso_tc_errors.erl b/src/aeso_tc_errors.erl index 3663a87..802ff56 100644 --- a/src/aeso_tc_errors.erl +++ b/src/aeso_tc_errors.erl @@ -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]), diff --git a/src/aeso_ets_manager.erl b/src/aeso_tc_ets_manager.erl similarity index 98% rename from src/aeso_ets_manager.erl rename to src/aeso_tc_ets_manager.erl index 3fcb276..fbc13c4 100644 --- a/src/aeso_ets_manager.erl +++ b/src/aeso_tc_ets_manager.erl @@ -1,4 +1,4 @@ --module(aeso_ets_manager). +-module(aeso_tc_ets_manager). -export([ ets_init/0 , ets_new/2 diff --git a/src/aeso_tc_pp.erl b/src/aeso_tc_pp.erl index 18c0219..80241b1 100644 --- a/src/aeso_tc_pp.erl +++ b/src/aeso_tc_pp.erl @@ -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]) -> diff --git a/src/aeso_type_utils.erl b/src/aeso_tc_type_utils.erl similarity index 82% rename from src/aeso_type_utils.erl rename to src/aeso_tc_type_utils.erl index 7c68ef5..68f748c 100644 --- a/src/aeso_type_utils.erl +++ b/src/aeso_tc_type_utils.erl @@ -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)} diff --git a/src/aeso_tc_warnings.erl b/src/aeso_tc_warnings.erl index 4600ea8..15f5b41 100644 --- a/src/aeso_tc_warnings.erl +++ b/src/aeso_tc_warnings.erl @@ -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 == []