diff options
| -rw-r--r-- | lib/typer/src/typer_annotator.erl | 157 |
1 files changed, 78 insertions, 79 deletions
diff --git a/lib/typer/src/typer_annotator.erl b/lib/typer/src/typer_annotator.erl index 68a8f03a5c..8904867d3e 100644 --- a/lib/typer/src/typer_annotator.erl +++ b/lib/typer/src/typer_annotator.erl @@ -2,7 +2,7 @@ %% %% %CopyrightBegin% %% -%% Copyright Ericsson AB 2008-2010. All Rights Reserved. +%% Copyright Ericsson AB 2008-2011. All Rights Reserved. %% %% The contents of this file are subject to the Erlang Public License, %% Version 1.1, (the "License"); you may not use this file except in @@ -34,46 +34,46 @@ -include("typer.hrl"). -%%---------------------------------------------------------------------------- + %%---------------------------------------------------------------------------- -define(TYPER_ANN_DIR, "typer_ann"). --type func_info() :: {non_neg_integer(), atom(), arity()}. +-type fun_info() :: {non_neg_integer(), atom(), arity()}. --record(info, {recMap = typer_map:new() :: dict(), - funcs = [] :: [func_info()], - typeMap :: dict(), - contracts :: boolean()}). +-record(info, {records = typer_map:new() :: dict(), + functions = [] :: [fun_info()], + types :: dict(), + no_comment_specs = true :: boolean()}). -record(inc, {map = typer_map:new() :: dict(), - filter = [] :: [string()]}). + filter = [] :: [file:filename()]}). %%---------------------------------------------------------------------------- -spec annotate(#typer_analysis{}) -> 'ok'. -annotate(Analysis) -> - case Analysis#typer_analysis.mode of +annotate(#typer_analysis{mode = Mode, final_files = Files} = Analysis) -> + case Mode of ?SHOW -> show(Analysis); ?SHOW_EXPORTED -> show(Analysis); ?ANNOTATE -> - Fun = fun({File, Module}) -> + Fun = fun ({File, Module}) -> Info = get_final_info(File, Module, Analysis), write_typed_file(File, Info) end, - lists:foreach(Fun, Analysis#typer_analysis.final_files); + lists:foreach(Fun, Files); ?ANNOTATE_INC_FILES -> IncInfo = write_and_collect_inc_info(Analysis), write_inc_files(IncInfo) end. write_and_collect_inc_info(Analysis) -> - Fun = fun({File, Module}, Inc) -> + Fun = fun ({File, Module}, Inc) -> Info = get_final_info(File, Module, Analysis), write_typed_file(File, Info), IncFuns = get_functions(File, Analysis), - collect_imported_funcs(IncFuns, Info#info.typeMap, Inc) + collect_imported_functions(IncFuns, Info#info.types, Inc) end, - NewInc = lists:foldl(Fun,#inc{}, Analysis#typer_analysis.final_files), + NewInc = lists:foldl(Fun, #inc{}, Analysis#typer_analysis.final_files), clean_inc(NewInc). write_inc_files(Inc) -> @@ -84,75 +84,75 @@ write_inc_files(Inc) -> %% in form [{{Line,F,A},Type}] Functions = [Key || {Key,_} <- Val], Val1 = [{{F,A},Type} || {{_Line,F,A},Type} <- Val], - Info = #info{typeMap = typer_map:from_list(Val1), - recMap = typer_map:new(), + Info = #info{types = typer_map:from_list(Val1), + records = typer_map:new(), %% Note we need to sort functions here! - funcs = lists:keysort(1, Functions)}, - %% io:format("TypeMap ~p\n", [Info#info.typeMap]), - %% io:format("Funcs ~p\n", [Info#info.funcs]), - %% io:format("RecMap ~p\n", [Info#info.recMap]), + functions = lists:keysort(1, Functions)}, + %% io:format("Types ~p\n", [Info#info.types]), + %% io:format("Functions ~p\n", [Info#info.functions]), + %% io:format("Records ~p\n", [Info#info.records]), write_typed_file(File, Info) end, lists:foreach(Fun, dict:fetch_keys(Inc#inc.map)). show(Analysis) -> - Fun = fun({File, Module}) -> + Fun = fun ({File, Module}) -> Info = get_final_info(File, Module, Analysis), - show_type_info_only(File, Info) + show_type_info(File, Info) end, lists:foreach(Fun, Analysis#typer_analysis.final_files). get_final_info(File, Module, Analysis) -> - RecMap = get_recMap(File, Analysis), - TypeMap = get_typeMap(Module, Analysis,RecMap), + Records = get_records(File, Analysis), + Types = get_types(Module, Analysis, Records), Functions = get_functions(File, Analysis), - Contracts = Analysis#typer_analysis.contracts, - #info{recMap=RecMap, funcs=Functions, typeMap=TypeMap, contracts=Contracts}. + Bool = Analysis#typer_analysis.contracts, + #info{records = Records, functions = Functions, + types = Types, no_comment_specs = Bool}. -collect_imported_funcs(Funcs, TypeMap, TmpInc) -> +collect_imported_functions(Functions, Types, Inc) -> %% Coming from other sourses, including: %% FIXME: How to deal with yecc-generated file???? %% --.yrl (yecc-generated file)??? %% -- yeccpre.hrl (yecc-generated file)??? %% -- other cases - Fun = fun({File,_} = Obj, Inc) -> - case is_yecc_file(File, Inc) of - {yecc_generated, NewInc} -> NewInc; - {not_yecc, NewInc} -> - check_imported_funcs(Obj, NewInc, TypeMap) + Fun = fun ({File, _} = Obj, I) -> + case is_yecc_gen(File, I) of + {true, NewI} -> NewI; + {false, NewI} -> + check_imported_functions(Obj, NewI, Types) end end, - lists:foldl(Fun, TmpInc, Funcs). + lists:foldl(Fun, Inc, Functions). --spec is_yecc_file(string(), #inc{}) -> {'not_yecc', #inc{}} - | {'yecc_generated', #inc{}}. -is_yecc_file(File, Inc) -> - case lists:member(File, Inc#inc.filter) of - true -> {yecc_generated, Inc}; +-spec is_yecc_gen(file:filename(), #inc{}) -> {boolean(), #inc{}}. + +is_yecc_gen(File, #inc{filter = Fs} = Inc) -> + case lists:member(File, Fs) of + true -> {true, Inc}; false -> case filename:extension(File) of ".yrl" -> Rootname = filename:rootname(File, ".yrl"), Obj = Rootname ++ ".erl", - case lists:member(Obj, Inc#inc.filter) of - true -> {yecc_generated, Inc}; + case lists:member(Obj, Fs) of + true -> {true, Inc}; false -> - NewFilter = [Obj|Inc#inc.filter], - NewInc = Inc#inc{filter = NewFilter}, - {yecc_generated, NewInc} + NewInc = Inc#inc{filter = [Obj|Fs]}, + {true, NewInc} end; _ -> case filename:basename(File) of - "yeccpre.hrl" -> {yecc_generated, Inc}; - _ -> {not_yecc, Inc} + "yeccpre.hrl" -> {true, Inc}; + _ -> {false, Inc} end end end. -check_imported_funcs({File, {Line, F, A}}, Inc, TypeMap) -> +check_imported_functions({File, {Line, F, A}}, Inc, Types) -> IncMap = Inc#inc.map, FA = {F, A}, - Type = get_type_info(FA, TypeMap), + Type = get_type_info(FA, Types), case typer_map:lookup(File, IncMap) of none -> %% File is not added. Add it Obj = {File,[{FA, {Line, Type}}]}, @@ -190,25 +190,24 @@ clean_inc(Inc) -> Inc1 = remove_yecc_generated_file(Inc), normalize_obj(Inc1). -remove_yecc_generated_file(TmpInc) -> - Fun = fun(Key, Inc) -> - NewMap = typer_map:remove(Key, Inc#inc.map), - Inc#inc{map = NewMap} +remove_yecc_generated_file(#inc{filter = Filter} = Inc) -> + Fun = fun (Key, #inc{map = Map} = I) -> + I#inc{map = typer_map:remove(Key, Map)} end, - lists:foldl(Fun, TmpInc, TmpInc#inc.filter). - + lists:foldl(Fun, Inc, Filter). + normalize_obj(TmpInc) -> - Fun = fun(Key, Val, Inc) -> + Fun = fun (Key, Val, Inc) -> NewVal = [{{Line,F,A},Type} || {{F,A},{Line,Type}} <- Val], typer_map:insert({Key,NewVal}, Inc) end, NewMap = typer_map:fold(Fun, typer_map:new(), TmpInc#inc.map), TmpInc#inc{map = NewMap}. -get_recMap(File, Analysis) -> +get_records(File, Analysis) -> typer_map:lookup(File, Analysis#typer_analysis.record). -get_typeMap(Module, Analysis, RecMap) -> +get_types(Module, Analysis, Records) -> TypeInfoPlt = Analysis#typer_analysis.trust_plt, TypeInfo = case dialyzer_plt:lookup_module(TypeInfoPlt, Module) of @@ -216,10 +215,10 @@ get_typeMap(Module, Analysis, RecMap) -> {value, List} -> List end, CodeServer = Analysis#typer_analysis.code_server, - TypeInfoList = [get_type(I, CodeServer, RecMap) || I <- TypeInfo], + TypeInfoList = [get_type(I, CodeServer, Records) || I <- TypeInfo], typer_map:from_list(TypeInfoList). -get_type({{M, F, A} = MFA, Range, Arg}, CodeServer, RecMap) -> +get_type({{M, F, A} = MFA, Range, Arg}, CodeServer, Records) -> case dialyzer_codeserver:lookup_mfa_contract(MFA, CodeServer) of error -> {{F, A}, {Range, Arg}}; @@ -231,7 +230,7 @@ get_type({{M, F, A} = MFA, Range, Arg}, CodeServer, RecMap) -> {{F, A}, {contract, Contract}}; {error, invalid_contract} -> CString = dialyzer_contracts:contract_to_string(Contract), - SigString = dialyzer_utils:format_sig(Sig, RecMap), + SigString = dialyzer_utils:format_sig(Sig, Records), typer:error( io_lib:format("Error in contract of function ~w:~w/~w\n" "\t The contract is: " ++ CString ++ "\n" ++ @@ -260,17 +259,17 @@ get_functions(File, Analysis) -> typer_map:lookup(File, Analysis#typer_analysis.inc_func) end. -normalize_incFuncs(Funcs) -> - [FuncInfo || {_FileName, FuncInfo} <- Funcs]. +normalize_incFuncs(Functions) -> + [FunInfo || {_FileName, FunInfo} <- Functions]. --spec remove_module_info([func_info()]) -> [func_info()]. +-spec remove_module_info([fun_info()]) -> [fun_info()]. -remove_module_info(FuncInfoList) -> +remove_module_info(FunInfoList) -> F = fun ({_,module_info,0}) -> false; ({_,module_info,1}) -> false; ({Line,F,A}) when is_integer(Line), is_atom(F), is_integer(A) -> true end, - lists:filter(F, FuncInfoList). + lists:filter(F, FunInfoList). write_typed_file(File, Info) -> io:format(" Processing file: ~p\n", [File]), @@ -278,7 +277,7 @@ write_typed_file(File, Info) -> RootName = filename:basename(filename:rootname(File)), Ext = filename:extension(File), TyperAnnDir = filename:join(Dir, ?TYPER_ANN_DIR), - TmpNewFilename = lists:concat([RootName,".ann",Ext]), + TmpNewFilename = lists:concat([RootName, ".ann", Ext]), NewFileName = filename:join(TyperAnnDir, TmpNewFilename), case file:make_dir(TyperAnnDir) of {error, Reason} -> @@ -291,7 +290,7 @@ write_typed_file(File, Info) -> eacces -> io:format(" No write permission in ~p\n", [Dir]); _ -> - io:format("Unknown error when writing ~p\n", [Dir]), + io:format("Unhandled error ~s when writing ~p\n", [Reason, Dir]), halt() end; ok -> %% Typer dir does NOT exist @@ -304,14 +303,14 @@ write_typed_file(File, Info, NewFileName) -> write_typed_file(Chars, NewFileName, Info, 1, []), io:format(" Saved as: ~p\n", [NewFileName]). -write_typed_file(Chars, File, #info{funcs = []}, _LNo, _Acc) -> +write_typed_file(Chars, File, #info{functions = []}, _LNo, _Acc) -> ok = file:write_file(File, list_to_binary(Chars), [append]); write_typed_file([Ch|Chs] = Chars, File, Info, LineNo, Acc) -> - [{Line,F,A}|RestFuncs] = Info#info.funcs, + [{Line,F,A}|RestFuncs] = Info#info.functions, case Line of 1 -> %% This will happen only for inc files ok = raw_write(F, A, Info, File, []), - NewInfo = Info#info{funcs = RestFuncs}, + NewInfo = Info#info{functions = RestFuncs}, NewAcc = [], write_typed_file(Chars, File, NewInfo, Line, NewAcc); _ -> @@ -322,7 +321,7 @@ write_typed_file([Ch|Chs] = Chars, File, Info, LineNo, Acc) -> case NewLineNo of Line -> ok = raw_write(F, A, Info, File, [Ch|Acc]), - {Info#info{funcs = RestFuncs}, []}; + {Info#info{functions = RestFuncs}, []}; _ -> {Info, [Ch|Acc]} end, @@ -339,16 +338,16 @@ raw_write(F, A, Info, File, Content) -> file:write_file(File, ContentBin, [append]). get_type_string(F, A, Info, Mode) -> - Type = get_type_info({F,A}, Info#info.typeMap), + Type = get_type_info({F,A}, Info#info.types), TypeStr = case Type of {contract, C} -> dialyzer_contracts:contract_to_string(C); {RetType, ArgType} -> - dialyzer_utils:format_sig(erl_types:t_fun(ArgType, RetType), - Info#info.recMap) + Sig = erl_types:t_fun(ArgType, RetType), + dialyzer_utils:format_sig(Sig, Info#info.records) end, - case Info#info.contracts of + case Info#info.no_comment_specs of true -> case {Mode, Type} of {file, {contract, _}} -> ""; @@ -361,7 +360,7 @@ get_type_string(F, A, Info, Mode) -> lists:concat([Prefix, TypeStr, "."]) end. -show_type_info_only(File, Info) -> +show_type_info(File, Info) -> io:format("\n%% File: ~p\n%% ", [File]), OutputString = lists:concat(["~.", length(File)+8, "c~n"]), io:fwrite(OutputString, [$-]), @@ -369,10 +368,10 @@ show_type_info_only(File, Info) -> TypeInfo = get_type_string(F, A, Info, show), io:format("~s\n", [TypeInfo]) end, - lists:foreach(Fun, Info#info.funcs). + lists:foreach(Fun, Info#info.functions). -get_type_info(Func, TypeMap) -> - case typer_map:lookup(Func, TypeMap) of +get_type_info(Func, Types) -> + case typer_map:lookup(Func, Types) of none -> %% Note: Typeinfo of any function should exist in %% the result offered by dialyzer, otherwise there |